//! Solana support for Icepick.
//!
//! # Command Line Operations
//!
//! The first thing you'll want is a wallet. For this, you can run the command
//! `icepick sol generate-wallet`. The output of the command will be a request to derive a key,
//! which Icepick will interpret upon subsequent invocations and replace with the derived key -
//! after appending the valid `bip44` path. You can then pipe the output of the command to
//! `icepick sol get-wallet-address`, which will take the derived key and format it as a Solana
//! address. In full, the commands look like:
//!
//! ```sh
//! icepick sol generate-wallet | icepick sol get-wallet-address
//! ```
//!
//! Next, you'll want to either airdrop some funds into the wallet if on devnet, or transfer some
//! funds using another source if on mainnet.
//!
//!
//! To transfer funds out of the wallet, you'll need a recent blockhash. The command
//! `icepick sol get-blockhash` can be used to get a recent blockhash. This blockhash must be used
//! within 150 blocks, or about 1 minute, or transactions won't be accepted.
//!
//! The blockhash is then used in the next command, `icepick sol transfer`, which also requires an
//! amount, a to-address, and a from-address. The output of this command can then be saved to
//! removable media, then transferred to an offline signer system where `icepick sol sign` is used
//! to sign the transaction, with the signed result also persisted to removable media. Once the
//! signed transaction is back on an online system, the transaction can be broadcasted using
//! `icepick sol broadcast`.
//!
//! ```sh
//! # On an online system
//! icepick sol get-blockhash > sdcard/blockhash.json
//!
//! # On an offline system
//! blockhash=$(jq -r .blob sdcard/blockhash.json)
//! icepick sol transfer $amount $to_address $from_address | icepick sol sign $blockhash > sdcard/transfer.json
//!
//! # On the online system, again
//! icepick sol broadcast --cluster devnet < sdcard/transfer.json
//! ```
//!
//! You may also want to transfer tokens on the Solana blockchain. You'll first need an account for
//! the token (let's use IPDBG, a devnet token I built for testing):
//!
//! ```sh
//! # On an online system
//! # Assume we have the wallet address as $wallet_address
//! icepick sol get-blockhash > sdcard/blockhash.json
//!
//! # On an offline system
//! blockhash=$(jq -r .blob sdcard/blockhash.json)
//! icepick sol get-token-info IPDBG > sdcard/ipdbg.json
//! token_address=$(jq -r .blob.token_address sdcard/ipdbg.json)
//! icepick sol create-token-account $wallet_address $token_address | icepick sol sign $blockhash > sdcard/create-account.json
//!
//! # On an online system
//! icepick sol broadcast --cluster devnet < sdcard/create-account.json
//! ```

use icepick_module::{
    help::{Argument, ArgumentType},
    Module,
};
use serde::{Deserialize, Serialize};
use solana_rpc_client::rpc_client::SerializableTransaction;
use solana_rpc_client_api::client_error::Result as ClientResult;
use solana_sdk::{
    pubkey::Pubkey,
    signer::{keypair::Keypair, Signer},
    system_instruction,
    transaction::TransactionError,
};
use std::{collections::HashSet, str::FromStr};

// How does this not exist in solana_sdk.
const LAMPORTS_PER_SOL: u64 = 1_000_000_000;

fn get_account(
    account_index: impl Into<Option<u8>>,
    account_keys: &[String],
    instruction_keys: &[u8],
) -> Pubkey {
    let instruction_index: usize = account_index
        .into()
        .expect("account index did not exist")
        .into();
    let account_index: usize = instruction_keys
        .get(instruction_index)
        .copied()
        .unwrap_or_else(|| panic!("instruction account {instruction_index} did not exist"))
        .into();
    let account_string = account_keys
        .get(account_index)
        .unwrap_or_else(|| panic!("account at index {account_index} did not exist"));
    Pubkey::from_str(account_string).expect("could not parse account from string")
}

#[derive(thiserror::Error, Debug)]
pub enum Error {}

#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
#[serde(rename_all = "kebab-case")]
pub enum Cluster {
    Devnet,
    Testnet,
    #[serde(alias = "mainnet")]
    MainnetBeta,
}

impl std::str::FromStr for Cluster {
    type Err = &'static str;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "devnet" => Ok(Self::Devnet),
            "testnet" => Ok(Self::Testnet),
            "mainnet" => Ok(Self::MainnetBeta),
            "mainnet-beta" => Ok(Self::MainnetBeta),
            _ => Err("Invalid value"),
        }
    }
}

impl std::fmt::Display for Cluster {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Cluster::Devnet => f.write_str("devnet"),
            Cluster::Testnet => f.write_str("testnet"),
            Cluster::MainnetBeta => f.write_str("mainnet-beta"),
        }
    }
}

// NOTE: While, technically, they both fit in the same width, it is _important_ to have different
// functionality based on which is provided, as Nonce requires an incremention instruction.
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "snake_case", untagged)]
pub enum Hashable {
    Nonce {
        nonce_data: String,
        nonce_address: String,
        nonce_authority: String,
    },
    Blockhash {
        blockhash: String,
    },
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetBlockhash {
    cluster: Option<Cluster>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GenerateWallet {
    account: Option<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetWalletAddress {}

#[derive(Serialize, Deserialize, Debug)]
pub struct AwaitFunds {
    address: String,
    lamports: String,
    cluster: Option<Cluster>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetTokenInfo {
    token: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateNonceAccountAndSigningKey {
    authorization_address: String,
    from_account: Option<String>,
    from_address: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetNonceAccountData {
    nonce_address: String,
    cluster: Option<Cluster>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct FindNonceAccounts {
    authorization_address: String,
    cluster: Option<Cluster>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Transfer {
    amount: String,
    to_address: String,
    from_account: Option<String>,
    from_address: String,
    fee: Option<String>,
    fee_payer: Option<String>,
    fee_payer_address: Option<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateTokenAccount {
    funder_address: Option<String>,
    wallet_address: String,
    token_address: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TransferToken {
    amount: String,
    token_address: String,
    to_address: String,
    from_account: Option<String>,
    from_address: String,
    decimals: String,
    fee: Option<String>,
    fee_payer: Option<String>,
    fee_payer_address: Option<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Compile {
    #[serde(flatten)]
    hashable: Hashable,
    derivation_accounts: Vec<u32>,
    instructions: Vec<solana_sdk::instruction::Instruction>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Inspect {
    transaction: solana_sdk::transaction::Transaction,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Sign {
    blockhash: String,
    transaction: solana_sdk::transaction::Transaction,
    #[serde(default)]
    signing_keys: Vec<[u8; Keypair::SECRET_KEY_LENGTH]>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Broadcast {
    cluster: Option<Cluster>,
    transaction: solana_sdk::transaction::Transaction,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Request {
    // NOTE: Can't use the proper XPrv type from Keyfork because Solana's a big stinky
    // and adds in its own derivation constructs that cause type conflicts.
    derived_keys: Option<Vec<[u8; 32]>>,

    #[serde(flatten)]
    operation: Operation,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(tag = "operation", content = "values", rename_all = "kebab-case")]
pub enum Operation {
    GetBlockhash(GetBlockhash),
    GenerateWallet(GenerateWallet),
    GetWalletAddress(GetWalletAddress),
    AwaitFunds(AwaitFunds),
    GetTokenInfo(GetTokenInfo),
    CreateNonceAccountAndSigningKey(CreateNonceAccountAndSigningKey),
    GetNonceAccountData(GetNonceAccountData),
    FindNonceAccounts(FindNonceAccounts),
    Transfer(Transfer),
    CreateTokenAccount(CreateTokenAccount),
    TransferToken(TransferToken),
    Compile(Compile),
    Inspect(Inspect),
    Sign(Sign),
    Broadcast(Broadcast),
}

pub struct Solana;

impl Solana {
    fn keypair_from_bytes(given_bytes: [u8; 32]) -> Keypair {
        use ed25519_dalek::{PublicKey, SecretKey};
        let secret_key = SecretKey::from_bytes(&given_bytes).expect("key should be 32 bytes");
        let mut bytes = [0u8; 64];
        bytes[..32].clone_from_slice(&given_bytes);
        bytes[32..].clone_from_slice(PublicKey::from(&secret_key).as_bytes());
        Keypair::from_bytes(&bytes).expect("solana sdk should expect 64 bytes")
    }
}

impl Module for Solana {
    type Error = Error;

    type Request = Request;

    fn describe_operations() -> Vec<icepick_module::help::Operation> {
        let cluster = Argument {
            name: "cluster".to_string(),
            description: "The cluster to interact with (mainnet, testnet, devnet)".to_string(),
            r#type: ArgumentType::Optional,
        };
        let account = Argument {
            name: "from_account".to_string(),
            description: "The derivation account used for the transaction.".to_string(),
            r#type: ArgumentType::Optional,
        };
        let fee = Argument {
            name: "fee".to_string(),
            description: "A custom fee for the transaction".to_string(),
            r#type: ArgumentType::Optional,
        };
        let fee_payer_address = Argument {
            name: "fee_payer_address".to_string(),
            description: "The address used to pay the fee.".to_string(),
            r#type: ArgumentType::Optional,
        };
        let fee_payer = Argument {
            name: "fee_payer".to_string(),
            description: "The derivation account used to pay the fee.".to_string(),
            r#type: ArgumentType::Optional,
        };
        let from_address = Argument {
            name: "from_address".to_string(),
            description: concat!(
                "The address to send SOL from; will be used to verify ",
                "the derivation account."
            )
            .to_string(),
            r#type: ArgumentType::Required,
        };
        let get_blockhash = icepick_module::help::Operation {
            name: "get-blockhash".to_string(),
            description: "Get the latest blockhash".to_string(),
            arguments: vec![cluster.clone()],
        };
        let generate_wallet = icepick_module::help::Operation {
            name: "generate-wallet".to_string(),
            description: "Generate the derivation index for a wallet.".to_string(),
            arguments: vec![Argument {
                name: "account".to_string(),
                description: "The derivation account used for generating the wallet.".to_string(),
                r#type: ArgumentType::Optional,
            }],
        };
        let get_wallet_address = icepick_module::help::Operation {
            name: "get-wallet-address".to_string(),
            description: "Get the address for a given wallet.".to_string(),
            arguments: vec![],
        };
        let await_funds = icepick_module::help::Operation {
            name: "await-funds".to_string(),
            description: "Await a minimum amount of funds in an account".to_string(),
            arguments: vec![
                Argument {
                    name: "address".to_string(),
                    description: "The address to monitor".to_string(),
                    r#type: ArgumentType::Required,
                },
                Argument {
                    name: "amount".to_string(),
                    description: "The amount of lamports to await".to_string(),
                    r#type: ArgumentType::Required,
                },
            ],
        };
        let get_token_info = icepick_module::help::Operation {
            name: "get-token-info".to_string(),
            description: "Get the address for a given token.".to_string(),
            arguments: vec![Argument {
                name: "token".to_string(),
                description: "The token to look up".to_string(),
                r#type: ArgumentType::Required,
            }],
        };
        let create_nonce_account_and_signing_key = icepick_module::help::Operation {
            name: "create-nonce-account-and-signing-key".to_string(),
            description: "Create a nonce account for signing durable transactions".to_string(),
            arguments: vec![
                account.clone(),
                from_address.clone(),
                Argument {
                    name: "authorization_address".to_string(),
                    description: "The account authorized to use and advance the nonce.".to_string(),
                    r#type: ArgumentType::Required,
                },
            ],
        };
        let get_nonce_account_data = icepick_module::help::Operation {
            name: "get-nonce-account-data".to_string(),
            description: "Get the data for a nonce account".to_string(),
            arguments: vec![
                cluster.clone(),
                Argument {
                    name: "nonce_address".to_string(),
                    description: "The address of the nonce account.".to_string(),
                    r#type: ArgumentType::Required,
                },
            ],
        };
        let find_nonce_accounts = icepick_module::help::Operation {
            name: "find-nonce-accounts".to_string(),
            description: "Find all nonce accounts for an authorized address".to_string(),
            arguments: vec![
                cluster.clone(),
                Argument {
                    name: "authorization_address".to_string(),
                    description: "The account authorized to use and advance nonces.".to_string(),
                    r#type: ArgumentType::Required,
                },
            ],
        };

        let transfer = icepick_module::help::Operation {
            name: "transfer".to_string(),
            description: "Transfer SOL from a Keyfork wallet to an external wallet.".to_string(),
            arguments: vec![
                Argument {
                    name: "amount".to_string(),
                    description: "The amount of SOL to transfer.".to_string(),
                    r#type: ArgumentType::Required,
                },
                account.clone(),
                Argument {
                    name: "to_address".to_string(),
                    description: "The address to send SOL to.".to_string(),
                    r#type: ArgumentType::Required,
                },
                from_address.clone(),
                fee.clone(),
                fee_payer.clone(),
                fee_payer_address.clone(),
            ],
        };
        let stake = icepick_module::help::Operation {
            name: "stake".to_string(),
            description: "Stake SOL to earn rewards.".to_string(),
            arguments: vec![
                Argument {
                    name: "amount".to_string(),
                    description: "The amount of SOL to stake.".to_string(),
                    r#type: ArgumentType::Required,
                },
                account.clone(),
                from_address.clone(),
                fee.clone(),
                fee_payer.clone(),
                fee_payer_address.clone(),
            ],
        };
        // kinda BS that you have to make an account for a token, but ok.
        let create_token_account = icepick_module::help::Operation {
            name: "create-token-account".to_string(),
            description: "Create an account for a given token".to_string(),
            arguments: vec![
                Argument {
                    name: "wallet_address".to_string(),
                    description: "The address of the token.".to_string(),
                    r#type: ArgumentType::Required,
                },
                Argument {
                    name: "token_address".to_string(),
                    description: "The address of the token.".to_string(),
                    r#type: ArgumentType::Required,
                },
                Argument {
                    name: "funder_address".to_string(),
                    description: "The address of the funder (signer).".to_string(),
                    r#type: ArgumentType::Optional,
                },
            ],
        };
        let transfer_token = icepick_module::help::Operation {
                name: "transfer-token".to_string(),
                description: "Transfer tokens from a Keyfork wallet to an external wallet."
                    .to_string(),
                arguments: vec![
                    Argument {
                        name: "amount".to_string(),
                        description: "The amount of tokens to transfer.".to_string(),
                        r#type: ArgumentType::Required,
                    },
                    Argument {
                        name: "token_address".to_string(),
                        description: "The address of the token.".to_string(),
                        r#type: ArgumentType::Required,
                    },
                    account.clone(),
                    Argument {
                        name: "to_address".to_string(),
                        description: "The address to send the tokens to.".to_string(),
                        r#type: ArgumentType::Required,
                    },
                    Argument {
                        name: "from_address".to_string(),
                        description: "The address to send the tokens from; will be used to verify the derivation account.".to_string(),
                        r#type: ArgumentType::Required,
                    },
                    Argument {
                        name: "decimals".to_string(),
                        description: "The decimals of the token.".to_string(),
                        r#type: ArgumentType::Required,
                    },
                    fee.clone(),
                    fee_payer.clone(),
                    fee_payer_address.clone(),
                ],
            };
        let compile = icepick_module::help::Operation {
            name: "compile".to_string(),
            description: "Compile instructions into a transaction".to_string(),
            arguments: vec![
                Argument {
                    name: "blockhash".to_string(),
                    description: "A recent blockhash, must be provided in place of nonce"
                        .to_string(),
                    r#type: ArgumentType::Optional,
                },
                Argument {
                    name: "nonce".to_string(),
                    description: "A durable nonce, must be provided in place of blockhash"
                        .to_string(),
                    r#type: ArgumentType::Optional,
                },
            ],
        };
        let inspect = icepick_module::help::Operation {
            name: "inspect".to_string(),
            description: "Print a transaction using base64.".to_string(),
            arguments: vec![],
        };
        let sign = icepick_module::help::Operation {
            name: "sign".to_string(),
            description: "Sign a previously-generated transaction.".to_string(),
            arguments: vec![Argument {
                name: "blockhash".to_string(),
                description: "A recent blockhash".to_string(),
                r#type: ArgumentType::Required,
            }],
        };
        let broadcast = icepick_module::help::Operation {
            name: "broadcast".to_string(),
            description: "Broadcast a signed transaction".to_string(),
            arguments: vec![cluster.clone()],
        };
        vec![
            get_blockhash,
            generate_wallet,
            get_wallet_address,
            await_funds,
            get_token_info,
            create_nonce_account_and_signing_key,
            get_nonce_account_data,
            find_nonce_accounts,
            transfer,
            stake,
            create_token_account,
            transfer_token,
            compile,
            inspect,
            sign,
            broadcast,
        ]
    }

    fn handle_request(request: Self::Request) -> Result<serde_json::Value, Self::Error> {
        match request.operation {
            Operation::GetBlockhash(GetBlockhash { cluster }) => {
                let cluster = cluster.unwrap_or(Cluster::MainnetBeta);
                let cluster_url = format!("https://api.{cluster}.solana.com");
                let client = solana_rpc_client::rpc_client::RpcClient::new(cluster_url);
                let response = client.get_latest_blockhash().unwrap();
                Ok(serde_json::json!({
                    "blob": {
                        "blockhash": response.to_string(),
                    },
                }))
            }
            Operation::GenerateWallet(GenerateWallet { account }) => {
                let account = u32::from_str(account.as_deref().unwrap_or("0")).unwrap();
                Ok(serde_json::json!({
                    "blob": {},
                    "derivation_accounts": [(account | 1 << 31)],
                }))
            }
            Operation::GetWalletAddress(_) => {
                // NOTE: panics if doesn't exist
                let key = request.derived_keys.unwrap()[0];
                let keypair = Self::keypair_from_bytes(key);
                let pubkey = keypair.pubkey();
                Ok(serde_json::json!({
                    "blob": {
                        "pubkey": pubkey.to_string(),
                    }
                }))
            }
            Operation::AwaitFunds(AwaitFunds {
                address,
                lamports,
                cluster,
            }) => {
                let cluster = cluster.unwrap_or(Cluster::MainnetBeta);
                let cluster_url = format!("https://api.{cluster}.solana.com");
                let client = solana_rpc_client::rpc_client::RpcClient::new(cluster_url);
                let account_pk = Pubkey::from_str(&address).unwrap();
                let minimum_balance = u64::from_str(&lamports).unwrap();

                let sleep = || {
                    std::thread::sleep(std::time::Duration::from_secs(10));
                };

                let account_balance = loop {
                    let account = match client.get_account(&account_pk) {
                        Ok(account) => account,
                        Err(_) => {
                            eprintln!("Waiting for account to be created and funded: {account_pk}");
                            sleep();
                            continue;
                        }
                    };
                    let account_size = account.data.len();
                    let rent = client
                        .get_minimum_balance_for_rent_exemption(account_size)
                        .unwrap();
                    let balance = account.lamports;
                    if balance
                        .checked_sub(rent)
                        .is_some_and(|bal| bal > minimum_balance)
                    {
                        break balance;
                    }
                    eprintln!("Waiting for {minimum_balance} + rent ({rent}) in {account_pk}");
                    sleep();
                };

                Ok(serde_json::json!({
                    "blob": {
                        "lamports": account_balance,
                    },
                }))
            }
            Operation::GetTokenInfo(GetTokenInfo { token }) => {
                let values = match token.as_str() {
                    // Only exists on devnet
                    "IPDBG" => Some(("3V6hm5ifSLSWLZ86NpTxo5iVguGq9qCUtry6bn5PtT23", 9u8)),
                    // Only exists on mainnet
                    "PYTH" => Some(("HZ1JovNiVvGrGNiiYvEozEVgZ58xaU3RKwX8eACQBCt3", 6u8)),
                    _ => None,
                };

                Ok(match values {
                    Some((address, decimals)) => serde_json::json!({
                        "blob": {
                            "token_address": address,
                            // forgive me father, for i have sinned
                            // see: https://git.distrust.co/public/icepick/issues/26
                            // TransferToken { decimals: String }
                            "token_decimals": decimals.to_string(),
                        }
                    }),
                    None => serde_json::json!({
                        "blob": {},
                        "error": "key was not found!",
                    }),
                })
            }
            Operation::CreateNonceAccountAndSigningKey(CreateNonceAccountAndSigningKey {
                authorization_address,
                from_account,
                from_address,
            }) => {
                // NOTE: Since this transaction is meant to be run on an online system with a
                // freshly generated mnemonic, only designed to live to make the nonce account, we
                // are going to assume we're not using a separate fee payer. It's a stretch having
                // a `--from-account` option, really, but it is probably to be expected given the
                // `from-address` variable. In truth, we will likely have the account randomly
                // generated using `generate-wallet | get-wallet-address`.

                // NOTE: new() calls generate() which requires CryptoRng. By default,
                // this uses OsRng, which sources from getrandom() if available, which pulls from
                // /dev/urandom, or sources from `/dev/urandom` directly.
                let keypair = Keypair::new();

                let from_pk = Pubkey::from_str(&from_address).unwrap();
                let authorization_pk = Pubkey::from_str(&authorization_address).unwrap();

                if from_account.is_some() {
                    unimplemented!("alternative derivation accounts are not yet implemented");
                }

                let instructions = system_instruction::create_nonce_account(
                    &from_pk,
                    &keypair.pubkey(),
                    &authorization_pk,
                    // just above the approximate rent necessary for a nonce account
                    1500000,
                );

                #[allow(clippy::identity_op)]
                Ok(serde_json::json!({
                    "blob": {
                        "nonce_pubkey": keypair.pubkey().to_string(),
                        "nonce_privkey": [keypair.secret().to_bytes()],
                        "transaction": instructions,
                        "derivation_accounts": [0u32 | 1 << 31],
                    },
                }))
            }
            Operation::GetNonceAccountData(GetNonceAccountData {
                nonce_address,
                cluster,
            }) => {
                let nonce_pk = Pubkey::from_str(&nonce_address).unwrap();
                let cluster = cluster.unwrap_or(Cluster::MainnetBeta);
                let cluster_url = format!("https://api.{cluster}.solana.com");
                let client = solana_rpc_client::rpc_client::RpcClient::new(cluster_url);

                let nonce_account = client.get_account(&nonce_pk).unwrap();
                let nonce =
                    solana_rpc_client_nonce_utils::data_from_account(&nonce_account).unwrap();

                Ok(serde_json::json!({
                    "blob": {
                        "authority": nonce.authority.to_string(),
                        "durable_nonce": nonce.durable_nonce.as_hash().to_string(),
                        "lamports_per_signature": nonce.fee_calculator.lamports_per_signature,
                    },
                }))
            }
            Operation::FindNonceAccounts(FindNonceAccounts {
                authorization_address,
                cluster,
            }) => {
                use solana_sdk::{
                    instruction::CompiledInstruction, system_instruction::SystemInstruction,
                };
                use solana_transaction_status_client_types::{
                    EncodedConfirmedTransactionWithStatusMeta, EncodedTransaction,
                    EncodedTransactionWithStatusMeta, UiMessage, UiRawMessage, UiTransaction,
                };

                let cluster = cluster.unwrap_or(Cluster::MainnetBeta);
                let cluster_url = format!("https://api.{cluster}.solana.com");
                let client = solana_rpc_client::rpc_client::RpcClient::new(cluster_url);

                let authorized_pk = Pubkey::from_str(&authorization_address).unwrap();

                let mut nonced_accounts: HashSet<Pubkey> = HashSet::new();

                let transaction_statuses =
                    client.get_signatures_for_address(&authorized_pk).unwrap();

                for status in transaction_statuses
                /*.iter().rev()*/
                {
                    let signature = solana_sdk::signature::Signature::from_str(&status.signature)
                        .expect("cluster provided invalid signature");
                    let transaction = client
                        .get_transaction_with_config(&signature, Default::default())
                        .unwrap();
                    let EncodedConfirmedTransactionWithStatusMeta {
                        slot: _,
                        block_time: _,
                        transaction:
                            EncodedTransactionWithStatusMeta {
                                meta: _,
                                version: _,
                                transaction:
                                    EncodedTransaction::Json(UiTransaction {
                                        signatures: _,
                                        message:
                                            UiMessage::Raw(UiRawMessage {
                                                header: _,
                                                account_keys,
                                                recent_blockhash: _,
                                                address_table_lookups: _,
                                                instructions,
                                            }),
                                    }),
                            },
                    }: EncodedConfirmedTransactionWithStatusMeta = transaction
                    else {
                        eprintln!("Unable to destructure transaction");
                        continue;
                    };
                    // search for program based on the following:
                    // * program is SystemProgram
                    // * instruction is
                    for ui_instruction in &instructions {
                        let instruction = CompiledInstruction {
                            program_id_index: ui_instruction.program_id_index,
                            accounts: ui_instruction.accounts.clone(),
                            data: bs58::decode(ui_instruction.data.as_bytes())
                                .into_vec()
                                .unwrap(),
                        };
                        let program_pk = account_keys
                            .get(instruction.program_id_index as usize)
                            .map(|k| &**k)
                            .map(Pubkey::from_str)
                            .transpose()
                            .ok()
                            .flatten()
                            .expect("could not get program key from transaction");
                        if solana_sdk::system_program::check_id(&program_pk) {
                            let parsed_instruction: SystemInstruction =
                                bincode::deserialize(&instruction.data).unwrap();
                            match parsed_instruction {
                                SystemInstruction::InitializeNonceAccount(pubkey) => {
                                    // [Nonce, RecentBlockhashes, Rent]
                                    // Argument is new authority
                                    let nonce_account =
                                        get_account(0, &account_keys, &instruction.accounts);
                                    if authorized_pk == pubkey {
                                        nonced_accounts.insert(nonce_account);
                                    }
                                }
                                SystemInstruction::AuthorizeNonceAccount(pubkey) => {
                                    // [Nonce, Authority]
                                    // Argument is new authority
                                    let nonce_account =
                                        get_account(0, &account_keys, &instruction.accounts);
                                    let authorizing_pk =
                                        get_account(1, &account_keys, &instruction.accounts);
                                    if authorized_pk == pubkey {
                                        // we are given it
                                        nonced_accounts.insert(nonce_account);
                                    } else if authorizing_pk == pubkey {
                                        // we are giving it
                                        nonced_accounts.remove(&nonce_account);
                                    }
                                }
                                SystemInstruction::WithdrawNonceAccount(_lamports) => {
                                    // [Nonce, Recipient, RecentBlockhashes, Rent, Authority]
                                    // Because the nonce account will be deleted due to nonpayment
                                    // of rent, we do not re-insert into created accounts.
                                    let nonce_account =
                                        get_account(0, &account_keys, &instruction.accounts);
                                    nonced_accounts.remove(&nonce_account);
                                }
                                _ => {}
                            }
                        }
                    }
                }
                let nonced_accounts = nonced_accounts
                    .iter()
                    .map(|account| account.to_string())
                    .collect::<Vec<_>>();
                Ok(serde_json::json!({
                    "blob": {
                        "nonced_accounts": nonced_accounts,
                    }
                }))
            }
            Operation::Transfer(Transfer {
                amount,
                from_account,
                to_address,
                from_address,
                fee,
                fee_payer,
                fee_payer_address,
            }) => {
                if from_account.is_some() {
                    unimplemented!("from_account");
                }
                if fee.is_some() | fee_payer.is_some() | fee_payer_address.is_some() {
                    unimplemented!("fee")
                }

                let amount = f64::from_str(&amount).expect("float amount");
                let amount: u64 = (amount * LAMPORTS_PER_SOL as f64) as u64;

                let to_pk = Pubkey::from_str(&to_address).unwrap();
                let from_pk = Pubkey::from_str(&from_address).unwrap();
                let instruction = system_instruction::transfer(&from_pk, &to_pk, amount);
                #[allow(clippy::identity_op)]
                Ok(serde_json::json!({
                    "blob": {
                        "instructions": [instruction],
                        // This is done in blob since it's compiled in the next step
                        "derivation_accounts": [0u32 | 1 << 31],
                    },
                }))
            }
            Operation::CreateTokenAccount(CreateTokenAccount {
                funder_address,
                wallet_address,
                token_address,
            }) => {
                // TODO: allow changing derivation account of funder_address
                use spl_associated_token_account as sata;

                use sata::instruction::create_associated_token_account;
                use spl_token::ID as TOKEN_ID;
                let funder_address = funder_address.unwrap_or_else(|| wallet_address.clone());
                let funder_pubkey = Pubkey::from_str(&funder_address).unwrap();
                let wallet_pubkey = Pubkey::from_str(&wallet_address).unwrap();
                let token_pubkey = Pubkey::from_str(&token_address).unwrap();
                let instruction = create_associated_token_account(
                    &funder_pubkey,
                    &wallet_pubkey,
                    &token_pubkey,
                    &TOKEN_ID,
                );
                let message =
                    solana_sdk::message::Message::new(&[instruction], Some(&funder_pubkey));
                let transaction = solana_sdk::transaction::Transaction::new_unsigned(message);
                #[allow(clippy::identity_op)]
                Ok(serde_json::json!({
                    "blob": {
                        "transaction": transaction,
                    },
                    "derivation_accounts": [0u32 | 1 << 31],
                }))
            }
            Operation::TransferToken(TransferToken {
                amount,
                token_address,
                to_address,
                from_account,
                from_address,
                decimals,
                fee,
                fee_payer,
                fee_payer_address,
            }) => {
                if from_account.is_some() {
                    unimplemented!("from_account");
                }
                if fee.is_some() | fee_payer.is_some() | fee_payer_address.is_some() {
                    unimplemented!("fee")
                }

                let amount = f64::from_str(&amount).expect("float amount");
                let decimals = u8::from_str(&decimals).expect("decimals");
                let amount: u64 = (amount * 10u64.pow(decimals as u32) as f64) as u64;

                use solana_sdk::pubkey::Pubkey;
                use spl_associated_token_account::get_associated_token_address;
                let to_pk = Pubkey::from_str(&to_address).unwrap();
                let from_pk = Pubkey::from_str(&from_address).unwrap();
                let token_pk = Pubkey::from_str(&token_address).unwrap();
                let token_program_id = spl_token::ID;

                let from_token_address = get_associated_token_address(&from_pk, &token_pk);
                let to_token_address = get_associated_token_address(&to_pk, &token_pk);
                let mut instruction = spl_token_2022::instruction::transfer_checked(
                    &token_program_id,   // token program id
                    &from_token_address, // source, as token address
                    &token_pk,           // mint
                    &to_token_address,   // destination, as token address
                    &from_pk,            // authority, as source sol address
                    // TODO: signers should be [] when not using multisig
                    // but should contain all signers when multisig
                    &[],      // signers
                    amount,   // amount
                    decimals, // decimals
                )
                .unwrap();

                // TODO: check if this works with multisig
                // this is required because the Solana SDK does not set the primary transactional
                // key as writable (the one that would be paying computation fees) in the event a
                // payer is not provided. The transactional account must be writable for the
                // computation fee to be paid.
                for account in instruction.accounts.iter_mut() {
                    if account.pubkey == from_pk {
                        account.is_writable = true;
                    }
                }

                #[allow(clippy::identity_op)]
                Ok(serde_json::json!({
                    "blob": {
                        "instructions": [instruction],
                        "derivation_accounts": [0u32 | 1 << 31],
                    },
                }))
            }
            Operation::Compile(Compile {
                hashable,
                derivation_accounts,
                mut instructions,
            }) => {
                use solana_sdk::{hash::Hash, message::Message, transaction::Transaction};

                let (hash, transaction) = match hashable {
                    // We already have the account from GetNonceAccountData,
                    // which also gives us the authority and the nonce itself.
                    Hashable::Nonce {
                        nonce_data,
                        nonce_address,
                        nonce_authority,
                    } => {
                        let account_pk = Pubkey::from_str(&nonce_address).unwrap();
                        let authority_pk = Pubkey::from_str(&nonce_authority).unwrap();

                        let hash = Hash::from_str(&nonce_data).unwrap();
                        let increment_nonce =
                            system_instruction::advance_nonce_account(&account_pk, &authority_pk);

                        instructions.insert(0, increment_nonce);
                        let message = Message::new(&instructions, None);
                        let transaction = Transaction::new_unsigned(message);
                        (hash, transaction)
                    }
                    Hashable::Blockhash { blockhash } => {
                        let blockhash = Hash::from_str(&blockhash).unwrap();
                        let message = Message::new(&instructions, None);
                        let transaction = Transaction::new_unsigned(message);
                        (blockhash, transaction)
                    }
                };
                Ok(serde_json::json!({
                    "blob": {
                        "hash": hash,
                        "transaction": transaction,
                    },
                    "derivation_accounts": derivation_accounts,
                }))
            }
            Operation::Inspect(Inspect { transaction }) => {
                use base64::prelude::*;

                Ok(serde_json::json!({
                    "blob": {
                        "formatted_transaction": BASE64_STANDARD.encode(transaction.message_data())
                    }
                }))
            }
            Operation::Sign(Sign {
                blockhash,
                mut transaction,
                signing_keys,
            }) => {
                let keys = request
                    .derived_keys
                    .unwrap_or_default()
                    .iter()
                    .chain(&signing_keys)
                    .map(|k| Self::keypair_from_bytes(*k))
                    .collect::<Vec<_>>();

                let hash = solana_sdk::hash::Hash::from_str(&blockhash).unwrap();
                transaction
                    .try_sign(&keys, hash)
                    .expect("not enough keys provided");
                Ok(serde_json::json!({
                    "blob": {
                        "transaction": transaction,
                    }
                }))
            }
            Operation::Broadcast(Broadcast {
                cluster,
                transaction,
            }) => {
                let cluster = cluster.unwrap_or(Cluster::MainnetBeta);
                let cluster_url = format!("https://api.{cluster}.solana.com");

                transaction.verify().expect("invalid signatures");
                let client = solana_rpc_client::rpc_client::RpcClient::new(cluster_url);
                let _simulated_response = client.simulate_transaction(&transaction).unwrap();
                let response = client.send_and_confirm_transaction(&transaction);
                let cluster_suffix = {
                    if cluster == Cluster::MainnetBeta {
                        String::new()
                    } else {
                        format!("?cluster={cluster}")
                    }
                };
                Ok(match response {
                    Ok(s) => {
                        serde_json::json!({
                            "blob": {
                                "status": "send_and_confirm",
                                "succcess": s.to_string(),
                                "url": format!("https://explorer.solana.com/tx/{s}{cluster_suffix}"),
                            }
                        })
                    }
                    Err(_) => {
                        let signature = transaction.get_signature();
                        let status = client.get_signature_status(signature);
                        blob_for_signature_status(status, signature, &cluster_suffix)
                    }
                })
            }
        }
    }
}

fn blob_for_signature_status(
    status: ClientResult<Option<Result<(), TransactionError>>>,
    signature: &solana_sdk::signature::Signature,
    cluster_suffix: &str,
) -> serde_json::Value {
    match status {
        Ok(Some(Ok(()))) => {
            // transaction passed.
            eprintln!("An error occurred while broadcasting the transaction, but the transaction was confirmed manually.");
            serde_json::json!({
                "blob": {
                    "status": "send_and_confirm",
                    "succcess": signature.to_string(),
                    "url": format!("https://explorer.solana.com/tx/{signature}{cluster_suffix}"),
                }
            })
        }
        Ok(Some(Err(e))) => {
            // transaction failed on-cluster
            eprintln!("The transaction failed on-chain: {e}");
            serde_json::json!({
                "blob": {
                    "status": "send_and_confirm",
                    "error": e.to_string(),
                }
            })
        }
        Ok(None) => {
            // transaction may not have been broadcast
            eprintln!("The transaction was possibly not received by the cluster.");
            serde_json::json!({
                "blob": {
                    "status": "send_and_confirm",
                    "error": format!("Transaction {signature} does not exist on-cluster"),
                }
            })
        }
        Err(e) => {
            // RPC request failed
            eprintln!("An error occurred while interacting with the cluster: {e}");
            serde_json::json!({
                "blob": {
                    "status": "send_and_confirm",
                    "error": e.to_string(),
                }
            })
        }
    }
}