Struct TIP20ChannelReserve 

pub struct TIP20ChannelReserve {
    pub channel_states: <Mapping<FixedBytes<32>, PackedChannelState> as StorableType>::Handler,
    pub opened_this_tx: <Mapping<FixedBytes<32>, bool> as StorableType>::Handler,
    pub channel_open_context_hash: <FixedBytes<32> as StorableType>::Handler,
    address: Address,
    storage: StorageCtx,
}

Fields

channel_states: <Mapping<FixedBytes<32>, PackedChannelState> as StorableType>::Handler

opened_this_tx: <Mapping<FixedBytes<32>, bool> as StorableType>::Handler

channel_open_context_hash: <FixedBytes<32> as StorableType>::Handler

address: Address

storage: StorageCtx

Implementations

impl TIP20ChannelReserve

pub fn new() -> TIP20ChannelReserve

Creates an instance of the precompile.

Caution: This does not initialize the account, see Self::initialize.

impl TIP20ChannelReserve

pub fn initialize(&mut self) -> Result<(), TempoPrecompileError>

Initializes the precompile storage layout.

pub fn set_channel_open_context_hash( &mut self, hash: FixedBytes<32>, ) -> Result<(), TempoPrecompileError>

Seeds the enclosing transaction’s replay-protected context hash for open calls.

The handler seeds keccak256(encode_for_signing || sender) for every real transaction type. The value is stored in transient storage so batched open calls share the same transaction-derived hash and the context is automatically cleared before the next transaction. If this is not called, open reads zero from transient storage and reverts.

pub fn open( &mut self, msg_sender: Address, call: openCall, ) -> Result<FixedBytes<32>, TempoPrecompileError>

Opens a channel and pulls the initial deposit from the payer into reserve.

Payees and integrators must independently decide whether any nonzero operator is acceptable before relying on the channel.

Payees cannot be zero or TIP-20 addresses. Virtual payees require a non-virtual operator. This prevents channels whose payee cannot receive direct payouts or submit vouchers itself.

pub fn settle( &mut self, msg_sender: Address, call: settleCall, ) -> Result<(), TempoPrecompileError>

Settles an increasing cumulative voucher, paying only the unsettled delta to the payee.

The payee can call directly. If an operator was set when the channel was opened, that operator can submit the payee’s voucher and route the payment to the descriptor payee.

pub fn top_up( &mut self, msg_sender: Address, call: topUpCall, ) -> Result<(), TempoPrecompileError>

Adds deposit to an existing channel and cancels a pending close request.

A zero top-up is allowed and only cancels a pending close request.

pub fn request_close( &mut self, msg_sender: Address, call: requestCloseCall, ) -> Result<(), TempoPrecompileError>

Starts the payer’s unilateral close timer.

Repeated calls are idempotent while the timer is active.

pub fn close( &mut self, msg_sender: Address, call: closeCall, ) -> Result<(), TempoPrecompileError>

Closes a channel from the payee side and refunds any uncaptured deposit to the payer.

The payee can call directly. If an operator was set when the channel was opened, that operator can close the channel and route any capture to the descriptor payee.

captureAmount can be below cumulativeAmount but cannot be below what has already settled. A new voucher is only required when the close captures more than settled.

pub fn withdraw( &mut self, msg_sender: Address, call: withdrawCall, ) -> Result<(), TempoPrecompileError>

Withdraws the payer’s remaining deposit after the close grace period has elapsed.

pub fn get_channel( &self, call: getChannelCall, ) -> Result<Channel, TempoPrecompileError>

Returns a descriptor with its current on-chain state.

pub fn get_channel_state( &self, call: getChannelStateCall, ) -> Result<ChannelState, TempoPrecompileError>

Returns the current state for a channel id, or the zero state for an empty slot.

pub fn get_channel_states_batch( &self, call: getChannelStatesBatchCall, ) -> Result<Vec<ChannelState>, TempoPrecompileError>

Returns current states for multiple channel ids.

pub fn compute_channel_id( &self, call: computeChannelIdCall, ) -> Result<FixedBytes<32>, TempoPrecompileError>

Computes the deterministic channel id for a full channel descriptor.

pub fn get_voucher_digest( &self, call: getVoucherDigestCall, ) -> Result<FixedBytes<32>, TempoPrecompileError>

Returns the EIP-712 digest that the payer or authorized signer must sign.

pub fn domain_separator(&self) -> Result<FixedBytes<32>, TempoPrecompileError>

Returns the EIP-712 domain separator for this chain and precompile address.

impl TIP20ChannelReserve

pub fn create_precompile(cfg: &CfgEnv<TempoHardfork>) -> DynPrecompile

Creates the EVM precompile for this type.

Trait Implementations

impl ContractStorage for TIP20ChannelReserve

fn address(&self) -> Address

Contract address.

fn storage(&self) -> &StorageCtx

Contract storage accessor.

fn storage_mut(&mut self) -> &mut StorageCtx

Contract storage mutable accessor.

fn is_initialized(&self) -> Result<bool, TempoPrecompileError>

Returns true if the contract has been initialized (has bytecode deployed).

impl Default for TIP20ChannelReserve

fn default() -> TIP20ChannelReserve

Returns the “default value” for a type.

impl Precompile for TIP20ChannelReserve

fn call( &mut self, calldata: &[u8], msg_sender: Address, ) -> Result<PrecompileOutput, PrecompileError>

Dispatches an EVM call to this precompile.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 296 bytes