Struct SpendingLimitState 

pub struct SpendingLimitState {
    pub remaining: U256,
    pub max: u128,
    pub period: u64,
    pub period_end: u64,
}

Per-token spending limit state.

remaining stays in the first slot so the legacy spending_limits layout remains intact. It remains U256 for the same reason, even though T3 caps max to TIP-20’s u128 supply range and runtime logic maintains remaining <= max for periodic limits. T3+ extends the same row with period metadata in later slots.

Fields

remaining: U256

Remaining amount currently available to spend.

max: u128

Maximum amount allowed per period, capped to TIP-20’s u128 supply range.

period: u64

Duration of each period in seconds. 0 means non-periodic.

period_end: u64

End timestamp of the current period window.

Implementations

impl SpendingLimitState

fn compute_next_period_end(&self, current_timestamp: u64) -> u64

Computes the period end for the current rollover window, saturating on all intermediate operations to avoid overflow in extreme timestamps.

Trait Implementations

impl Clone for SpendingLimitState

fn clone(&self) -> SpendingLimitState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpendingLimitState

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

Formats the value using the given formatter.

impl Default for SpendingLimitState

fn default() -> SpendingLimitState

Returns the “default value” for a type.

impl Handler<SpendingLimitState> for SpendingLimitStateHandler

fn t_read(&self) -> Result<SpendingLimitState>

Reads the struct from transient storage.

fn t_write(&mut self, value: SpendingLimitState) -> Result<()>

Writes the struct to transient storage.

fn t_delete(&mut self) -> Result<()>

Deletes the struct from transient storage.

fn read(&self) -> Result<SpendingLimitState>

Reads the value from storage.

fn write(&mut self, value: SpendingLimitState) -> Result<()>

Writes the value to storage.

fn delete(&mut self) -> Result<()>

Deletes the value from storage (sets to zero).

impl PartialEq for SpendingLimitState

fn eq(&self, other: &SpendingLimitState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Storable for SpendingLimitState

fn load<S: StorageOps>( storage: &S, base_slot: U256, ctx: LayoutCtx, ) -> Result<Self>

Load this type from storage at the given slot.

fn store<S: StorageOps>( &self, storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<()>

Store this type to storage at the given slot.

fn delete<S: StorageOps>( storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<()>

Delete this type from storage (set to zero).

impl StorableType for SpendingLimitState

const LAYOUT: Layout

Describes how this type is laid out in storage.

const IS_DYNAMIC: bool

Whether this type stores it’s data in its base slot or not.

type Handler = SpendingLimitStateHandler

The handler type that provides storage access for this type.

fn handle(slot: U256, _ctx: LayoutCtx, address: Address) -> Self::Handler

Creates a handler for this type at the given storage location.

const SLOTS: usize = _

Number of storage slots this type takes.

const BYTES: usize = _

Number of bytes this type takes.

const IS_PACKABLE: bool = _

Whether this type can be packed with adjacent fields.

impl Eq for SpendingLimitState

impl StructuralPartialEq for SpendingLimitState

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: 64 bytes