Struct near_contract_tools::approval::simple_multisig::ApprovalState

pub struct ApprovalState {
    pub approved_by: Vec<AccountId>,
    pub created_at_nanoseconds: u64,
}

Approval state for simple multisig

Fields

approved_by: Vec<AccountId>

List of accounts that have approved an action thus far

created_at_nanoseconds: u64

Network timestamp when the request was created

Implementations

impl ApprovalState

pub fn new() -> Self

Creates an ApprovalState with the current network timestamp

Trait Implementations

impl<Au, Ac> ApprovalConfiguration<Ac, ApprovalState> for Configuration<Au>where
    Au: AccountAuthorizer,

type ApprovalError = ApprovalError

Errors when approving a request

type RemovalError = RemovalError

Errors when removing a request

type AuthorizationError = <Au as AccountAuthorizer>::AuthorizationError

Errors when authorizing an account

type ExecutionEligibilityError = ExecutionEligibilityError

Errors when evaluating a request for execution candidacy

fn is_approved_for_execution(
    &self,
    action_request: &ActionRequest<Ac, ApprovalState>
) -> Result<(), ExecutionEligibilityError>

Has the request reached full approval?

fn is_removable(
    &self,
    action_request: &ActionRequest<Ac, ApprovalState>
) -> Result<(), Self::RemovalError>

Can this request be removed by an allowed account?

fn is_account_authorized(
    &self,
    account_id: &AccountId,
    _action_request: &ActionRequest<Ac, ApprovalState>
) -> Result<(), Self::AuthorizationError>

Is the account allowed to execute, approve, or remove this request?

fn try_approve_with_authorized_account(
    &self,
    account_id: AccountId,
    action_request: &mut ActionRequest<Ac, ApprovalState>
) -> Result<(), Self::ApprovalError>

Modify action_request.approval_state in-place to increase approval

impl BorshDeserialize for ApprovalStatewhere
    Vec<AccountId>: BorshDeserialize,
    u64: BorshDeserialize,

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.

impl BorshSerialize for ApprovalStatewhere
    Vec<AccountId>: BorshSerialize,
    u64: BorshSerialize,

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

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

Serialize this instance into a vector of bytes.

impl Debug for ApprovalState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ApprovalState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ApprovalState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ApprovalState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.