Struct SpendingLimit 

pub struct SpendingLimit {
    pub multisig: Pubkey,
    pub create_key: Pubkey,
    pub vault_index: u8,
    pub mint: Pubkey,
    pub amount: u64,
    pub period: Period,
    pub remaining_amount: u64,
    pub last_reset: i64,
    pub bump: u8,
    pub members: Vec<Pubkey>,
    pub destinations: Vec<Pubkey>,
}

Fields

multisig: Pubkey

The multisig this belongs to.

create_key: Pubkey

Key that is used to seed the SpendingLimit PDA.

vault_index: u8

The index of the vault that the spending limit is for.

mint: Pubkey

The token mint the spending limit is for. Pubkey::default() means SOL. use NATIVE_MINT for Wrapped SOL.

amount: u64

The amount of tokens that can be spent in a period. This amount is in decimals of the mint, so 1 SOL would be 1_000_000_000 and 1 USDC would be 1_000_000.

period: Period

The reset period of the spending limit. When it passes, the remaining amount is reset, unless it’s Period::OneTime.

remaining_amount: u64

The remaining amount of tokens that can be spent in the current period. When reaches 0, the spending limit cannot be used anymore until the period reset.

last_reset: i64

Unix timestamp marking the last time the spending limit was reset (or created).

bump: u8

PDA bump.

members: Vec<Pubkey>

Members of the multisig that can use the spending limit. In case a member is removed from the multisig, the spending limit will remain existent (until explicitly deleted), but the removed member will not be able to use it anymore.

destinations: Vec<Pubkey>

The destination addresses the spending limit is allowed to sent funds to. If empty, funds can be sent to any address.

Implementations

impl SpendingLimit

pub fn size(members_length: usize, destinations_length: usize) -> usize

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

Trait Implementations

impl AccountDeserialize for SpendingLimit

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 SpendingLimit

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

Serializes the account data into writer.

impl BorshDeserialize for SpendingLimit

where Pubkey: BorshDeserialize, u8: BorshDeserialize, u64: BorshDeserialize, Period: BorshDeserialize, i64: BorshDeserialize, Vec<Pubkey>: 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 SpendingLimit

where Pubkey: BorshSerialize, u8: BorshSerialize, u64: BorshSerialize, Period: BorshSerialize, i64: BorshSerialize, Vec<Pubkey>: 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 SpendingLimit

fn clone(&self) -> SpendingLimit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Discriminator for SpendingLimit

const DISCRIMINATOR: [u8; 8]

fn discriminator() -> [u8; 8]

impl Owner for SpendingLimit

fn owner() -> Pubkey