Trait openbrush_contracts::traits::timelock_controller::timelockcontroller_external::TimelockController

pub trait TimelockController: ContractEnv {
    type isOperationOutput: ImpliesReturn<bool>;
    type isOperationPendingOutput: ImpliesReturn<bool>;
    type isOperationReadyOutput: ImpliesReturn<bool>;
    type isOperationDoneOutput: ImpliesReturn<bool>;
    type getTimestampOutput: ImpliesReturn<Timestamp>;
    type getMinDelayOutput: ImpliesReturn<Timestamp>;
    type hashOperationOutput: ImpliesReturn<Hash>;
    type hashOperationBatchOutput: ImpliesReturn<Hash>;
    type scheduleOutput: ImpliesReturn<Result<(), TimelockControllerError>>;
    type scheduleBatchOutput: ImpliesReturn<Result<(), TimelockControllerError>>;
    type cancelOutput: ImpliesReturn<Result<(), TimelockControllerError>>;
    type executeOutput: ImpliesReturn<Result<(), TimelockControllerError>>;
    type executeBatchOutput: ImpliesReturn<Result<(), TimelockControllerError>>;
    type updateDelayOutput: ImpliesReturn<Result<(), TimelockControllerError>>;

    // Required methods
    fn is_operation(&self, id: OperationId) -> Self::isOperationOutput;
    fn is_operation_pending(
        &self,
        id: OperationId
    ) -> Self::isOperationPendingOutput;
    fn is_operation_ready(
        &self,
        id: OperationId
    ) -> Self::isOperationReadyOutput;
    fn is_operation_done(&self, id: OperationId) -> Self::isOperationDoneOutput;
    fn get_timestamp(&self, id: OperationId) -> Self::getTimestampOutput;
    fn get_min_delay(&self) -> Self::getMinDelayOutput;
    fn hash_operation(
        &self,
        transaction: Transaction,
        predecessor: Option<OperationId>,
        salt: [u8; 32]
    ) -> Self::hashOperationOutput;
    fn hash_operation_batch(
        &self,
        transactions: Vec<Transaction>,
        predecessor: Option<OperationId>,
        salt: [u8; 32]
    ) -> Self::hashOperationBatchOutput;
    fn schedule(
        &mut self,
        transaction: Transaction,
        predecessor: Option<OperationId>,
        salt: [u8; 32],
        delay: Timestamp
    ) -> Self::scheduleOutput;
    fn schedule_batch(
        &mut self,
        transactions: Vec<Transaction>,
        predecessor: Option<OperationId>,
        salt: [u8; 32],
        delay: Timestamp
    ) -> Self::scheduleBatchOutput;
    fn cancel(&mut self, id: OperationId) -> Self::cancelOutput;
    fn execute(
        &mut self,
        transaction: Transaction,
        predecessor: Option<OperationId>,
        salt: [u8; 32]
    ) -> Self::executeOutput;
    fn execute_batch(
        &mut self,
        transactions: Vec<Transaction>,
        predecessor: Option<OperationId>,
        salt: [u8; 32]
    ) -> Self::executeBatchOutput;
    fn update_delay(&mut self, new_delay: Timestamp) -> Self::updateDelayOutput;
}

Contract module which acts as a time-locked controller. When set as the owner of an Ownable smart contract, it enforces a timelock on all onlyOwner maintenance operations. This gives time for users of the controlled contract to exit before a potentially dangerous maintenance operation is applied.

By default, this contract is self-administered, meaning administration tasks have to go through the timelock process. The proposer (resp executor) role is in charge of proposing (resp executing) operations. A common use case is to position this TimelockController as the owner of a smart contract, with a multisig or a DAO as the sole proposer.

Required Associated Types

type isOperationOutput: ImpliesReturn<bool>

Output type of the respective trait message.

type isOperationPendingOutput: ImpliesReturn<bool>

Output type of the respective trait message.

type isOperationReadyOutput: ImpliesReturn<bool>

Output type of the respective trait message.

type isOperationDoneOutput: ImpliesReturn<bool>

Output type of the respective trait message.

type getTimestampOutput: ImpliesReturn<Timestamp>

Output type of the respective trait message.

type getMinDelayOutput: ImpliesReturn<Timestamp>

Output type of the respective trait message.

type hashOperationOutput: ImpliesReturn<Hash>

Output type of the respective trait message.

type hashOperationBatchOutput: ImpliesReturn<Hash>

Output type of the respective trait message.

type scheduleOutput: ImpliesReturn<Result<(), TimelockControllerError>>

Output type of the respective trait message.

type scheduleBatchOutput: ImpliesReturn<Result<(), TimelockControllerError>>

Output type of the respective trait message.

type cancelOutput: ImpliesReturn<Result<(), TimelockControllerError>>

Output type of the respective trait message.

type executeOutput: ImpliesReturn<Result<(), TimelockControllerError>>

Output type of the respective trait message.

type executeBatchOutput: ImpliesReturn<Result<(), TimelockControllerError>>

Output type of the respective trait message.

type updateDelayOutput: ImpliesReturn<Result<(), TimelockControllerError>>

Output type of the respective trait message.

Required Methods

fn is_operation(&self, id: OperationId) -> Self::isOperationOutput

fn is_operation_pending( &self, id: OperationId ) -> Self::isOperationPendingOutput

fn is_operation_ready(&self, id: OperationId) -> Self::isOperationReadyOutput

fn is_operation_done(&self, id: OperationId) -> Self::isOperationDoneOutput

fn get_timestamp(&self, id: OperationId) -> Self::getTimestampOutput

fn get_min_delay(&self) -> Self::getMinDelayOutput

fn hash_operation( &self, transaction: Transaction, predecessor: Option<OperationId>, salt: [u8; 32] ) -> Self::hashOperationOutput

fn hash_operation_batch( &self, transactions: Vec<Transaction>, predecessor: Option<OperationId>, salt: [u8; 32] ) -> Self::hashOperationBatchOutput

fn schedule( &mut self, transaction: Transaction, predecessor: Option<OperationId>, salt: [u8; 32], delay: Timestamp ) -> Self::scheduleOutput

fn schedule_batch( &mut self, transactions: Vec<Transaction>, predecessor: Option<OperationId>, salt: [u8; 32], delay: Timestamp ) -> Self::scheduleBatchOutput

fn cancel(&mut self, id: OperationId) -> Self::cancelOutput

fn execute( &mut self, transaction: Transaction, predecessor: Option<OperationId>, salt: [u8; 32] ) -> Self::executeOutput

fn execute_batch( &mut self, transactions: Vec<Transaction>, predecessor: Option<OperationId>, salt: [u8; 32] ) -> Self::executeBatchOutput

fn update_delay(&mut self, new_delay: Timestamp) -> Self::updateDelayOutput

Implementations on Foreign Types

impl<E> TimelockController for TraitDefinitionRegistry<E>where E: Environment,

type isOperationOutput = bool

fn is_operation(&self, __ink_binding_0: OperationId) -> Self::isOperationOutput

type isOperationPendingOutput = bool

fn is_operation_pending( &self, __ink_binding_0: OperationId ) -> Self::isOperationPendingOutput

type isOperationReadyOutput = bool

fn is_operation_ready( &self, __ink_binding_0: OperationId ) -> Self::isOperationReadyOutput

type isOperationDoneOutput = bool

fn is_operation_done( &self, __ink_binding_0: OperationId ) -> Self::isOperationDoneOutput

type getTimestampOutput = <DefaultEnvironment as Environment>::Timestamp

fn get_timestamp( &self, __ink_binding_0: OperationId ) -> Self::getTimestampOutput

type getMinDelayOutput = <DefaultEnvironment as Environment>::Timestamp

fn get_min_delay(&self) -> Self::getMinDelayOutput

type hashOperationOutput = <DefaultEnvironment as Environment>::Hash

fn hash_operation( &self, __ink_binding_0: Transaction, __ink_binding_1: Option<OperationId>, __ink_binding_2: [u8; 32] ) -> Self::hashOperationOutput

type hashOperationBatchOutput = <DefaultEnvironment as Environment>::Hash

fn hash_operation_batch( &self, __ink_binding_0: Vec<Transaction>, __ink_binding_1: Option<OperationId>, __ink_binding_2: [u8; 32] ) -> Self::hashOperationBatchOutput

type scheduleOutput = Result<(), TimelockControllerError>

fn schedule( &mut self, __ink_binding_0: Transaction, __ink_binding_1: Option<OperationId>, __ink_binding_2: [u8; 32], __ink_binding_3: Timestamp ) -> Self::scheduleOutput

type scheduleBatchOutput = Result<(), TimelockControllerError>

fn schedule_batch( &mut self, __ink_binding_0: Vec<Transaction>, __ink_binding_1: Option<OperationId>, __ink_binding_2: [u8; 32], __ink_binding_3: Timestamp ) -> Self::scheduleBatchOutput

type cancelOutput = Result<(), TimelockControllerError>

fn cancel(&mut self, __ink_binding_0: OperationId) -> Self::cancelOutput

type executeOutput = Result<(), TimelockControllerError>

fn execute( &mut self, __ink_binding_0: Transaction, __ink_binding_1: Option<OperationId>, __ink_binding_2: [u8; 32] ) -> Self::executeOutput

type executeBatchOutput = Result<(), TimelockControllerError>

fn execute_batch( &mut self, __ink_binding_0: Vec<Transaction>, __ink_binding_1: Option<OperationId>, __ink_binding_2: [u8; 32] ) -> Self::executeBatchOutput

type updateDelayOutput = Result<(), TimelockControllerError>

fn update_delay( &mut self, __ink_binding_0: Timestamp ) -> Self::updateDelayOutput

Implementors