multisig 0.1.0

Created with Anchor
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
97
98
99

use anchor_lang::prelude::*;

use crate::{
    state::{error::MultisigError, group::Group, member::GroupMember},
    Permissions,
};

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct AddMemberInResetModeArgs {
    pub new_member: Pubkey,
    pub weight: u32,
    pub permissions: Permissions,
}

#[derive(Accounts)]
#[instruction(args: AddMemberInResetModeArgs)]
pub struct AddMemberInResetModeAccounts<'info> {
    #[account(
        mut,
        seeds = [b"group", group.group_seed.as_ref()],
        bump = group.account_bump
    )]
    pub group: Account<'info, Group>,

    #[account(
        init,
        payer = payer,
        space = 8 + GroupMember::INIT_SPACE,
        seeds = [b"member", group.key().as_ref(), args.new_member.as_ref()],
        bump,
    )]
    pub new_member_account: Account<'info, GroupMember>,

    pub trusted_1: Signer<'info>,
    pub trusted_2: Signer<'info>,
    pub trusted_3: Signer<'info>,

    #[account(mut)]
    pub payer: Signer<'info>,

    pub system_program: Program<'info, System>,
}

#[inline(always)]
fn checks(
    ctx: &Context<AddMemberInResetModeAccounts>,
    args: &AddMemberInResetModeArgs,
) -> Result<()> {
    require!(ctx.accounts.group.paused, MultisigError::GroupNotPaused);

    require_keys_eq!(
        ctx.accounts.trusted_1.key(),
        ctx.accounts.group.reset_trusted_1,
        MultisigError::InvalidTrustedMember
    );
    require_keys_eq!(
        ctx.accounts.trusted_2.key(),
        ctx.accounts.group.reset_trusted_2,
        MultisigError::InvalidTrustedMember
    );
    require_keys_eq!(
        ctx.accounts.trusted_3.key(),
        ctx.accounts.group.reset_trusted_3,
        MultisigError::InvalidTrustedMember
    );

    require_gt!(args.weight, 0, MultisigError::InvalidMemberWeight);
    require_gte!(
        ctx.accounts.group.max_member_weight,
        args.weight,
        MultisigError::InvalidMemberWeight
    );
    args.permissions.is_valid()?;

    Ok(())
}

/// Adds a group member while paused. All three trusted members must sign.
pub fn add_member_in_reset_mode_handler(
    ctx: Context<AddMemberInResetModeAccounts>,
    args: AddMemberInResetModeArgs,
) -> Result<()> {
    checks(&ctx, &args)?;

    let group = &mut ctx.accounts.group;

    ctx.accounts.new_member_account.set_inner(GroupMember::new(
        args.new_member,
        group.key(),
        args.permissions,
        args.weight,
        ctx.bumps.new_member_account,
        group.max_member_weight,
    )?);

    group.increment_member_count()?;

    Ok(())
}