Struct Multisig 

pub struct Multisig {
    pub create_key: Pubkey,
    pub config_authority: Pubkey,
    pub threshold: u16,
    pub time_lock: u32,
    pub transaction_index: u64,
    pub stale_transaction_index: u64,
    pub rent_collector: Option<Pubkey>,
    pub bump: u8,
    pub members: Vec<Member>,
}

Fields

create_key: Pubkey

Key that is used to seed the multisig PDA.

config_authority: Pubkey

The authority that can change the multisig config. This is a very important parameter as this authority can change the members and threshold.

The convention is to set this to Pubkey::default(). In this case, the multisig becomes autonomous, so every config change goes through the normal process of voting by the members.

However, if this parameter is set to any other key, all the config changes for this multisig will need to be signed by the config_authority. We call such a multisig a “controlled multisig”.

threshold: u16

Threshold for signatures.

time_lock: u32

How many seconds must pass between transaction voting settlement and execution.

transaction_index: u64

Last transaction index. 0 means no transactions have been created.

stale_transaction_index: u64

Last stale transaction index. All transactions up until this index are stale. This index is updated when multisig config (members/threshold/time_lock) changes.

rent_collector: Option<Pubkey>

The address where the rent for the accounts related to executed, rejected, or cancelled transactions can be reclaimed. If set to None, the rent reclamation feature is turned off.

bump: u8

Bump for the multisig PDA seed.

members: Vec<Member>

Members of the multisig.

Implementations

impl Multisig

pub fn size(members_length: usize) -> usize

pub fn num_voters(members: &[Member]) -> usize

pub fn num_proposers(members: &[Member]) -> usize

pub fn num_executors(members: &[Member]) -> usize

pub fn realloc_if_needed<'a>( multisig: AccountInfo<'a>, members_length: usize, rent_payer: Option<AccountInfo<'a>>, system_program: Option<AccountInfo<'a>>, ) -> Result<bool>

Check if the multisig account space needs to be reallocated to accommodate members_length. Returns true if the account was reallocated.

pub fn invariant(&self) -> Result<()>

pub fn invalidate_prior_transactions(&mut self)

Makes the transactions created up until this moment stale. Should be called whenever any multisig parameter related to the voting consensus is changed.

pub fn is_member(&self, member_pubkey: Pubkey) -> Option<usize>

Returns Some(index) if member_pubkey is a member, with index into the members vec. None otherwise.

pub fn member_has_permission( &self, member_pubkey: Pubkey, permission: Permission, ) -> bool

pub fn cutoff(&self) -> usize

How many “reject” votes are enough to make the transaction “Rejected”. The cutoff must be such that it is impossible for the remaining voters to reach the approval threshold. For example: total voters = 7, threshold = 3, cutoff = 5.

pub fn add_member(&mut self, new_member: Member)

Add new_member to the multisig members vec and sort the vec.

pub fn remove_member(&mut self, member_pubkey: Pubkey) -> Result<()>

Remove member_pubkey from the multisig members vec.

Errors

• MultisigError::NotAMember if member_pubkey is not a member.

Trait Implementations

impl AccountDeserialize for Multisig

fn try_deserialize(buf: &mut &[u8]) -> Result<Self>

Deserializes previously initialized account data. Should fail for all uninitialized accounts, where the bytes are zeroed. Implementations should be unique to a particular account type so that one can never successfully deserialize the data of one account type into another. For example, if the SPL token program were to implement this trait, it should be impossible to deserialize a Mint account into a token Account.

fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self>

Deserializes account data without checking the account discriminator. This should only be used on account initialization, when the bytes of the account are zeroed.

impl AccountSerialize for Multisig

fn try_serialize<W: Write>(&self, writer: &mut W) -> Result<()>

Serializes the account data into writer.

impl BorshDeserialize for Multisig

where Pubkey: BorshDeserialize, u16: BorshDeserialize, u32: BorshDeserialize, u64: BorshDeserialize, Option<Pubkey>: BorshDeserialize, u8: BorshDeserialize, Vec<Member>: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for Multisig

where Pubkey: BorshSerialize, u16: BorshSerialize, u32: BorshSerialize, u64: BorshSerialize, Option<Pubkey>: BorshSerialize, u8: BorshSerialize, Vec<Member>: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for Multisig

fn clone(&self) -> Multisig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Discriminator for Multisig

const DISCRIMINATOR: [u8; 8]

fn discriminator() -> [u8; 8]

impl Owner for Multisig

fn owner() -> Pubkey