multisig-lite 0.0.8

A native SOL multisig on-chain program
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! `multisig_list::multisig_list::approve` instruction example.
//!
//! Run with:
//! ```
//! cargo run --example approve
//! ```

use std::error::Error;
use std::rc::Rc;

use clap::{Parser, ValueEnum};
use solana_sdk::commitment_config::CommitmentConfig;
use solana_sdk::instruction::AccountMeta;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::read_keypair_file;
use solana_sdk::signer::Signer;

use anchor_client::{Client, Cluster};

#[derive(Debug, Parser)]
struct Args {
    /// A Solana cluster.
    #[arg(short, long, value_enum, default_value_t = ClusterArg::Localnet)]
    cluster: ClusterArg,
}

#[derive(Copy, Clone, Debug, PartialEq, Eq, ValueEnum)]
enum ClusterArg {
    Mainnet,
    Devnet,
    Localnet,
}

impl From<ClusterArg> for Cluster {
    fn from(arg: ClusterArg) -> Self {
        match arg {
            ClusterArg::Mainnet => Self::Mainnet,
            ClusterArg::Devnet => Self::Devnet,
            ClusterArg::Localnet => Self::Localnet,
        }
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let args = Args::parse();
    let signer = Rc::new(read_keypair_file(
        shellexpand::tilde("~/.config/solana/id.json").as_ref(),
    )?);
    let url = args.cluster.into();
    let opts = CommitmentConfig::processed();
    let pid = multisig_lite::id();
    let program = Client::new_with_options(url, signer.clone(), opts).program(pid);

    // Gets the PDAs.
    let (state_pda, _state_bump) =
        Pubkey::find_program_address(&[b"state", signer.pubkey().as_ref()], &pid);
    let (fund_pda, fund_bump) = Pubkey::find_program_address(&[b"fund", state_pda.as_ref()], &pid);

    // Gets the pending transfers and the recipients account info.
    let mut remaining_accounts = vec![];
    let state: multisig_lite::State = program.account(state_pda)?;
    for transfer_pubkey in state.queue {
        let transfer: multisig_lite::Transfer = program.account(transfer_pubkey)?;

        // Pushes the transfer account.
        remaining_accounts.push(AccountMeta {
            pubkey: transfer_pubkey,
            is_signer: false,
            is_writable: true,
        });

        // Pushes the recipient account.
        remaining_accounts.push(AccountMeta {
            pubkey: transfer.recipient,
            is_signer: false,
            is_writable: true,
        });
    }

    // Approve the multisig account.
    let sig = program
        .request()
        .accounts(multisig_lite::accounts::Approve {
            signer: signer.pubkey(),
            state: state_pda,
            fund: fund_pda,
        })
        .args(multisig_lite::instruction::Approve { fund_bump })
        .accounts(remaining_accounts)
        .signer(signer.as_ref())
        .send()?;

    println!("{sig}");

    Ok(())
}