Struct polymesh_api::polymesh::api::pips::CallApi

pub struct CallApi<'api> { /* private fields */ }

Implementations

impl<'api> CallApi<'api>

pub fn set_prune_historical_pips(&self, prune: bool) -> Result<WrappedCall<'api>>

Change whether completed PIPs are pruned. Can only be called by root.

Arguments

• prune specifies whether completed PIPs should be pruned.

pub fn set_min_proposal_deposit(
    &self,
    deposit: u128
) -> Result<WrappedCall<'api>>

Change the minimum proposal deposit amount required to start a proposal. Can only be called by root.

Arguments

• deposit the new min deposit required to start a proposal

pub fn set_default_enactment_period(
    &self,
    duration: u32
) -> Result<WrappedCall<'api>>

Change the default enactment period. Can only be called by root.

Arguments

• duration the new default enactment period it takes for a scheduled PIP to be executed.

pub fn set_pending_pip_expiry(
    &self,
    expiry: MaybeBlock<u32>
) -> Result<WrappedCall<'api>>

Change the amount of blocks after which a pending PIP is expired. If expiry is None then PIPs never expire. Can only be called by root.

Arguments

• expiry the block-time it takes for a still-Pending PIP to expire.

pub fn set_max_pip_skip_count(&self, max: u8) -> Result<WrappedCall<'api>>

Change the maximum skip count (max_pip_skip_count). Can only be called by root.

Arguments

• max skips before a PIP cannot be skipped by GC anymore.

pub fn set_active_pip_limit(&self, limit: u32) -> Result<WrappedCall<'api>>

Change the maximum number of active PIPs before community members cannot propose anything. Can only be called by root.

Arguments

• limit of concurrent active PIPs.

pub fn propose(
    &self,
    proposal: Call,
    deposit: u128,
    url: Option<Url>,
    description: Option<PipDescription>
) -> Result<WrappedCall<'api>>

A network member creates a PIP by submitting a dispatchable which changes the network in someway. A minimum deposit is required to open a new proposal.

Arguments

• proposer is either a signing key or committee. Used to understand whether this is a committee proposal and verified against origin.
• proposal a dispatchable call
• deposit minimum deposit value, which is ignored if proposer is a committee.
• url a link to a website for proposal discussion

pub fn vote(
    &self,
    id: PipId,
    aye_or_nay: bool,
    deposit: u128
) -> Result<WrappedCall<'api>>

Vote either in favor (aye_or_nay == true) or against a PIP with id. The “convinction” or strength of the vote is given by deposit, which is reserved.

Note that vote is not additive. That is, vote(id, true, 50) followed by vote(id, true, 40) will first reserve 50 and then refund 50 - 10, ending up with 40 in deposit. To add atop of existing votes, you’ll need existing_deposit + addition.

Arguments

• id, proposal id
• aye_or_nay, a bool representing for or against vote
• deposit, the “conviction” with which the vote is made.

Errors

• NoSuchProposal if id doesn’t reference a valid PIP.
• NotFromCommunity if proposal was made by a committee.
• IncorrectProposalState if PIP isn’t pending.
• InsufficientDeposit if origin cannot reserve deposit - old_deposit.

pub fn approve_committee_proposal(&self, id: PipId) -> Result<WrappedCall<'api>>

Approves the pending committee PIP given by the id.

Errors

• BadOrigin unless a GC voting majority executes this function.
• NoSuchProposal if the PIP with id doesn’t exist.
• IncorrectProposalState if the proposal isn’t pending.
• NotByCommittee if the proposal isn’t by a committee.

pub fn reject_proposal(&self, id: PipId) -> Result<WrappedCall<'api>>

Rejects the PIP given by the id, refunding any bonded funds, assuming it hasn’t been cancelled or executed. Note that proposals scheduled-for-execution can also be rejected.

Errors

• BadOrigin unless a GC voting majority executes this function.
• NoSuchProposal if the PIP with id doesn’t exist.
• IncorrectProposalState if the proposal was cancelled or executed.

pub fn prune_proposal(&self, id: PipId) -> Result<WrappedCall<'api>>

Prune the PIP given by the id, refunding any funds not already refunded. The PIP may not be active

This function is intended for storage garbage collection purposes.

Errors

• BadOrigin unless a GC voting majority executes this function.
• NoSuchProposal if the PIP with id doesn’t exist.
• IncorrectProposalState if the proposal is active.

pub fn reschedule_execution(
    &self,
    id: PipId,
    until: Option<u32>
) -> Result<WrappedCall<'api>>

Updates the execution schedule of the PIP given by id.

Arguments

• until defines the future block where the enactment period will finished. None value means that enactment period is going to finish in the next block.

Errors

• RescheduleNotByReleaseCoordinator unless triggered by release coordinator.
• IncorrectProposalState unless the proposal was in a scheduled state.

pub fn clear_snapshot(&self) -> Result<WrappedCall<'api>>

Clears the snapshot and emits the event SnapshotCleared.

Errors

• NotACommitteeMember - triggered when a non-GC-member executes the function.

pub fn snapshot(&self) -> Result<WrappedCall<'api>>

Takes a new snapshot of the current list of active && pending PIPs. The PIPs are then sorted into a priority queue based on each PIP’s weight.

Errors

• NotACommitteeMember - triggered when a non-GC-member executes the function.

pub fn enact_snapshot_results(
    &self,
    results: Vec<(PipId, SnapshotResult)>
) -> Result<WrappedCall<'api>>

Enacts results for the PIPs in the snapshot queue. The snapshot will be available for further enactments until it is cleared.

The results are encoded a list of (id, result) where result is applied to id. Note that the snapshot priority queue is encoded with the lowest priority first. so results = [(id, Approve)] will approve SnapshotQueue[SnapshotQueue.len() - 1].

Errors

• BadOrigin - unless a GC voting majority executes this function.
• CannotSkipPip - a given PIP has already been skipped too many times.
• SnapshotResultTooLarge - on len(results) > len(snapshot_queue).
• SnapshotIdMismatch - if:

   ∃ (i ∈ 0..SnapshotQueue.len()).
     results[i].0 ≠ SnapshotQueue[SnapshotQueue.len() - i].id

  This is protects against clearing queue while GC is voting.

pub fn execute_scheduled_pip(&self, id: PipId) -> Result<WrappedCall<'api>>

Internal dispatchable that handles execution of a PIP.

pub fn expire_scheduled_pip(
    &self,
    did: IdentityId,
    id: PipId
) -> Result<WrappedCall<'api>>

Internal dispatchable that handles expiration of a PIP.

Trait Implementations

impl<'api> Clone for CallApi<'api>

fn clone(&self) -> CallApi<'api>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'api> From<&'api Api> for CallApi<'api>

fn from(api: &'api Api) -> Self

Converts to this type from the input type.