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

//! `multisig_list::multisig_list::create_transfer` instruction example.
//!
//! Run with:
//! ```
//! cargo run --example create-transfer
//! ```

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

use clap::{Parser, ValueEnum};
use solana_sdk::commitment_config::CommitmentConfig;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::read_keypair_file;
use solana_sdk::signer::{keypair::Keypair, Signer};
use solana_sdk::system_program;

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,

    /// Lamports to fund to the multisig fund account, 0.001SOL by default.
    #[arg(short, long, default_value_t = 1_000_000)]
    lamports: u64,
}

#[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 funder = 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, funder.clone(), opts).program(pid);

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

    // Temporary transfer keypair.
    //
    // This is only required for the transaction signature and
    // won't be required once the transaction is recorded on the
    // ledger.
    let transfer = Keypair::new();

    // Creates a pending transfer.
    let sig = program
        .request()
        .accounts(multisig_lite::accounts::CreateTransfer {
            creator: funder.pubkey(),
            state: state_pda,
            fund: fund_pda,
            transfer: transfer.pubkey(),
            system_program: system_program::id(),
        })
        .args(multisig_lite::instruction::CreateTransfer {
            recipient: Pubkey::new_unique(),
            lamports: args.lamports,
            fund_bump,
        })
        .signer(funder.as_ref())
        .signer(&transfer)
        .send()?;

    println!("{sig}");

    Ok(())
}