Struct TIP20Token 

pub struct TIP20Token {

    pub roles: <Mapping<Address, Mapping<B256, bool>> as StorableType>::Handler,
    pub role_admins: <Mapping<B256, B256> as StorableType>::Handler,
    pub name: <String as StorableType>::Handler,
    pub symbol: <String as StorableType>::Handler,
    pub currency: <String as StorableType>::Handler,
    pub domain_separator: <B256 as StorableType>::Handler,
    pub quote_token: <Address as StorableType>::Handler,
    pub next_quote_token: <Address as StorableType>::Handler,
    pub transfer_policy_id: <u64 as StorableType>::Handler,
    pub total_supply: <U256 as StorableType>::Handler,
    pub balances: <Mapping<Address, U256> as StorableType>::Handler,
    pub allowances: <Mapping<Address, Mapping<Address, U256>> as StorableType>::Handler,
    pub nonces: <Mapping<Address, U256> as StorableType>::Handler,
    pub paused: <bool as StorableType>::Handler,
    pub supply_cap: <U256 as StorableType>::Handler,
    pub salts: <Mapping<B256, bool> as StorableType>::Handler,
    pub global_reward_per_token: <U256 as StorableType>::Handler,
    pub last_update_time: <u64 as StorableType>::Handler,
    pub total_reward_per_second: <U256 as StorableType>::Handler,
    pub opted_in_supply: <u128 as StorableType>::Handler,
    pub next_stream_id: <u64 as StorableType>::Handler,
    pub streams: <Mapping<u64, RewardStream> as StorableType>::Handler,
    pub scheduled_rate_decrease: <Mapping<u128, U256> as StorableType>::Handler,
    pub user_reward_info: <Mapping<Address, UserRewardInfo> as StorableType>::Handler,
    pub fee_recipient: <Address as StorableType>::Handler,
    address: Address,
    storage: StorageCtx,
}

Fields

roles: <Mapping<Address, Mapping<B256, bool>> as StorableType>::Handler

role_admins: <Mapping<B256, B256> as StorableType>::Handler

name: <String as StorableType>::Handler

symbol: <String as StorableType>::Handler

currency: <String as StorableType>::Handler

domain_separator: <B256 as StorableType>::Handler

quote_token: <Address as StorableType>::Handler

next_quote_token: <Address as StorableType>::Handler

transfer_policy_id: <u64 as StorableType>::Handler

total_supply: <U256 as StorableType>::Handler

balances: <Mapping<Address, U256> as StorableType>::Handler

allowances: <Mapping<Address, Mapping<Address, U256>> as StorableType>::Handler

nonces: <Mapping<Address, U256> as StorableType>::Handler

paused: <bool as StorableType>::Handler

supply_cap: <U256 as StorableType>::Handler

salts: <Mapping<B256, bool> as StorableType>::Handler

global_reward_per_token: <U256 as StorableType>::Handler

last_update_time: <u64 as StorableType>::Handler

total_reward_per_second: <U256 as StorableType>::Handler

opted_in_supply: <u128 as StorableType>::Handler

next_stream_id: <u64 as StorableType>::Handler

streams: <Mapping<u64, RewardStream> as StorableType>::Handler

scheduled_rate_decrease: <Mapping<u128, U256> as StorableType>::Handler

user_reward_info: <Mapping<Address, UserRewardInfo> as StorableType>::Handler

fee_recipient: <Address as StorableType>::Handler

address: Address

storage: StorageCtx

Implementations

impl TIP20Token

pub fn start_reward( &mut self, msg_sender: Address, call: startRewardCall, ) -> Result<u64>

Starts a new reward stream for the token contract.

This function allows an authorized user to fund a reward stream that distributes tokens to opted-in recipients either immediately if seconds=0, or over the specified duration.

pub fn accrue(&mut self, accrue_to_timestamp: U256) -> Result<()>

Accrues rewards based on elapsed time since last update.

This function calculates and updates the reward per token stored based on the total reward rate and the time elapsed since the last update. Only processes rewards if there is an opted-in supply.

pub fn update_rewards(&mut self, holder: Address) -> Result<Address>

Updates and accumulates accrued rewards for a specific token holder.

This function calculates the rewards earned by a holder based on their balance and the reward per token difference since their last update. Rewards are accumulated in the delegated recipient’s rewardBalance. Returns the holder’s delegated recipient address.

pub fn set_reward_recipient( &mut self, msg_sender: Address, call: setRewardRecipientCall, ) -> Result<()>

Sets or changes the reward recipient for a token holder.

This function allows a token holder to designate who should receive their share of rewards. Setting to zero address opts out of rewards.

pub fn cancel_reward( &mut self, msg_sender: Address, call: cancelRewardCall, ) -> Result<U256>

Cancels an active reward stream and refunds remaining tokens.

This function allows the funder of a reward stream to cancel it early, stopping future reward distribution and refunding unused tokens.

pub fn finalize_streams( &mut self, msg_sender: Address, end_time: u128, ) -> Result<()>

Finalizes expired reward streams by updating the total reward rate.

This function is called to clean up streams that have reached their end time, reducing the total reward per second rate by the amount of the expired streams.

pub fn claim_rewards(&mut self, msg_sender: Address) -> Result<U256>

Claims accumulated rewards for a recipient.

This function allows a reward recipient to claim their accumulated rewards and receive them as token transfers to their own balance.

pub fn get_next_stream_id(&self) -> Result<u64>

Gets the next available stream ID (minimum 1).

fn set_next_stream_id(&mut self, value: u64) -> Result<()>

Sets the next stream ID counter.

fn get_global_reward_per_token(&self) -> Result<U256>

Gets the accumulated global reward per token.

fn set_global_reward_per_token(&mut self, value: U256) -> Result<()>

Sets the accumulated global reward per token in storage.

fn get_last_update_time(&self) -> Result<u64>

Gets the timestamp of the last reward update from storage.

fn set_last_update_time(&mut self, value: u64) -> Result<()>

Sets the timestamp of the last reward update in storage.

pub fn get_opted_in_supply(&self) -> Result<u128>

Gets the total supply of tokens opted into rewards from storage.

pub fn set_opted_in_supply(&mut self, value: u128) -> Result<()>

Sets the total supply of tokens opted into rewards in storage.

fn get_scheduled_rate_decrease_at(&self, end_time: u128) -> Result<U256>

Gets the scheduled rate decrease at a specific time from storage.

fn set_scheduled_rate_decrease_at( &mut self, end_time: u128, value: U256, ) -> Result<()>

Sets the scheduled rate decrease at a specific time in storage.

pub fn get_total_reward_per_second(&self) -> Result<U256>

Gets the total reward per second rate from storage.

fn set_total_reward_per_second(&mut self, value: U256) -> Result<()>

Sets the total reward per second rate in storage.

pub fn handle_rewards_on_transfer( &mut self, from: Address, to: Address, amount: U256, ) -> Result<()>

Handles reward accounting for both sender and receiver during token transfers.

pub fn handle_rewards_on_mint( &mut self, to: Address, amount: U256, ) -> Result<()>

Handles reward accounting when tokens are minted to an address.

pub fn get_stream(&self, stream_id: u64) -> Result<RewardStream>

Retrieves a reward stream by its ID.

pub fn get_user_reward_info(&self, account: Address) -> Result<UserRewardInfo>

Retrieves user reward information for a given account.

impl TIP20Token

pub fn initialize_roles(&mut self) -> Result<()>

Initialize the UNGRANTABLE_ROLE to be self-administered

pub fn grant_default_admin(&mut self, admin: Address) -> Result<()>

Grant the default admin role to an account

pub fn has_role(&self, call: hasRoleCall) -> Result<bool>

pub fn get_role_admin(&self, call: getRoleAdminCall) -> Result<B256>

pub fn grant_role( &mut self, msg_sender: Address, call: grantRoleCall, ) -> Result<()>

pub fn revoke_role( &mut self, msg_sender: Address, call: revokeRoleCall, ) -> Result<()>

pub fn renounce_role( &mut self, msg_sender: Address, call: renounceRoleCall, ) -> Result<()>

pub fn set_role_admin( &mut self, msg_sender: Address, call: setRoleAdminCall, ) -> Result<()>

pub fn check_role(&self, account: Address, role: B256) -> Result<()>

pub fn has_role_internal(&self, account: Address, role: B256) -> Result<bool>

pub fn grant_role_internal( &mut self, account: Address, role: B256, ) -> Result<()>

fn revoke_role_internal(&mut self, account: Address, role: B256) -> Result<()>

fn get_role_admin_internal(&self, role: B256) -> Result<B256>

If sloads 0, will be equal to DEFAULT_ADMIN_ROLE

fn set_role_admin_internal( &mut self, role: B256, admin_role: B256, ) -> Result<()>

fn check_role_internal(&self, account: Address, role: B256) -> Result<()>

impl TIP20Token

fn __new(address: Address) -> Self

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

fn emit_event(&mut self, event: impl IntoLogData) -> Result<()>

fn emitted_events(&self) -> &Vec<LogData>

Available on crate features test-utils only.

fn assert_emitted_events(&self, expected: Vec<impl IntoLogData>)

Available on crate features test-utils only.

impl TIP20Token

pub fn name(&self) -> Result<String>

pub fn symbol(&self) -> Result<String>

pub fn decimals(&self) -> Result<u8>

pub fn currency(&self) -> Result<String>

pub fn total_supply(&self) -> Result<U256>

pub fn quote_token(&self) -> Result<Address>

pub fn next_quote_token(&self) -> Result<Address>

pub fn supply_cap(&self) -> Result<U256>

pub fn paused(&self) -> Result<bool>

pub fn transfer_policy_id(&self) -> Result<u64>

pub fn pause_role() -> B256

Returns the PAUSE_ROLE constant

This role identifier grants permission to pause the token contract. The role is computed as keccak256("PAUSE_ROLE").

pub fn unpause_role() -> B256

Returns the UNPAUSE_ROLE constant

This role identifier grants permission to unpause the token contract. The role is computed as keccak256("UNPAUSE_ROLE").

pub fn issuer_role() -> B256

Returns the ISSUER_ROLE constant

This role identifier grants permission to mint and burn tokens. The role is computed as keccak256("ISSUER_ROLE").

pub fn burn_blocked_role() -> B256

Returns the BURN_BLOCKED_ROLE constant

This role identifier grants permission to burn tokens from blocked accounts. The role is computed as keccak256("BURN_BLOCKED_ROLE").

pub fn balance_of(&self, call: balanceOfCall) -> Result<U256>

pub fn allowance(&self, call: allowanceCall) -> Result<U256>

pub fn change_transfer_policy_id( &mut self, msg_sender: Address, call: changeTransferPolicyIdCall, ) -> Result<()>

pub fn set_supply_cap( &mut self, msg_sender: Address, call: setSupplyCapCall, ) -> Result<()>

pub fn pause(&mut self, msg_sender: Address, _call: pauseCall) -> Result<()>

pub fn unpause(&mut self, msg_sender: Address, _call: unpauseCall) -> Result<()>

pub fn set_next_quote_token( &mut self, msg_sender: Address, call: setNextQuoteTokenCall, ) -> Result<()>

pub fn complete_quote_token_update( &mut self, msg_sender: Address, _call: completeQuoteTokenUpdateCall, ) -> Result<()>

pub fn set_fee_recipient( &mut self, msg_sender: Address, new_recipient: Address, ) -> Result<()>

Sets a new fee recipient

pub fn get_fee_recipient(&self, _msg_sender: Address) -> Result<Address>

Gets the current fee recipient

pub fn mint(&mut self, msg_sender: Address, call: mintCall) -> Result<()>

Mints new tokens to specified address

pub fn mint_with_memo( &mut self, msg_sender: Address, call: mintWithMemoCall, ) -> Result<()>

Mints new tokens to specified address with memo attached

fn _mint( &mut self, msg_sender: Address, to: Address, amount: U256, ) -> Result<()>

Internal helper to mint new tokens and update balances

pub fn burn(&mut self, msg_sender: Address, call: burnCall) -> Result<()>

Burns tokens from sender’s balance and reduces total supply

pub fn burn_with_memo( &mut self, msg_sender: Address, call: burnWithMemoCall, ) -> Result<()>

Burns tokens from sender’s balance with memo attached

pub fn burn_blocked( &mut self, msg_sender: Address, call: burnBlockedCall, ) -> Result<()>

Burns tokens from blocked addresses that cannot transfer

fn _burn(&mut self, msg_sender: Address, amount: U256) -> Result<()>

pub fn approve( &mut self, msg_sender: Address, call: approveCall, ) -> Result<bool>

pub fn transfer( &mut self, msg_sender: Address, call: transferCall, ) -> Result<bool>

pub fn transfer_from( &mut self, msg_sender: Address, call: transferFromCall, ) -> Result<bool>

pub fn transfer_from_with_memo( &mut self, msg_sender: Address, call: transferFromWithMemoCall, ) -> Result<bool>

Transfer from from to to address with memo attached

pub fn system_transfer_from( &mut self, from: Address, to: Address, amount: U256, ) -> Result<bool>

Transfer from from to to address without approval requirement This function is not exposed via the public interface and should only be invoked by precompiles

fn _transfer_from( &mut self, msg_sender: Address, from: Address, to: Address, amount: U256, ) -> Result<bool>

pub fn transfer_with_memo( &mut self, msg_sender: Address, call: transferWithMemoCall, ) -> Result<()>

impl TIP20Token

pub fn new(token_id: u64) -> Self

pub fn from_address(address: Address) -> Result<Self>

Create a TIP20Token from an address. Returns an error if the address is not a valid TIP20 token (post-AllegroModerato).

pub fn initialize( &mut self, name: &str, symbol: &str, currency: &str, quote_token: Address, admin: Address, fee_recipient: Address, ) -> Result<()>

Only called internally from the factory, which won’t try to re-initialize a token.

fn get_balance(&self, account: Address) -> Result<U256>

fn set_balance(&mut self, account: Address, amount: U256) -> Result<()>

fn get_allowance(&self, owner: Address, spender: Address) -> Result<U256>

fn set_allowance( &mut self, owner: Address, spender: Address, amount: U256, ) -> Result<()>

fn set_total_supply(&mut self, amount: U256) -> Result<()>

fn check_not_paused(&self) -> Result<()>

fn check_not_token_address(&self, to: Address) -> Result<()>

pub fn is_transfer_authorized(&self, from: Address, to: Address) -> Result<bool>

Checks if the transfer is authorized.

pub fn ensure_transfer_authorized( &self, from: Address, to: Address, ) -> Result<()>

Ensures the transfer is authorized.

fn _transfer(&mut self, from: Address, to: Address, amount: U256) -> Result<()>

pub fn transfer_fee_pre_tx(&mut self, from: Address, amount: U256) -> Result<()>

Transfers fee tokens from user to fee manager before transaction execution

pub fn transfer_fee_post_tx( &mut self, to: Address, refund: U256, actual_spending: U256, ) -> Result<()>

Refunds unused fee tokens to user and emits transfer event for gas amount used

Trait Implementations

impl ContractStorage for TIP20Token

fn address(&self) -> Address

Contract address.

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

Contract storage accessor.

impl Precompile for TIP20Token

fn call(&mut self, calldata: &[u8], msg_sender: Address) -> PrecompileResult

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