Struct Contract

pub struct Contract { /* private fields */ }

Implementations

impl Contract

pub fn ensure_auth_predecessor_id(&self) -> AccountId

pub fn add_public_key_and_emit_event( &mut self, account_id: &AccountIdRef, public_key: PublicKey, )

pub fn remove_public_key_and_emit_event( &mut self, account_id: &AccountIdRef, public_key: PublicKey, )

impl Contract

pub const STATE_INIT_GAS: Gas

Covers StateInit (NEP-616) cost when deterministic account doesn’t exist yet. Only accounts for deploying via Global Contract ref (NEP-591) with <770B storage which doesn’t require storage staking.

pub fn do_auth_call(signer_id: AccountId, auth_call: AuthCall) -> Promise

impl Contract

pub fn auth_call_callback_gas(auth_call: &AuthCall) -> Option<Gas>

Computes the static gas assigned to the do_auth_call callback.

impl Contract

pub fn ft_resolve_deposit( &mut self, receiver_id: AccountId, contract_id: AccountId, amount: U128, ) -> PromiseOrValue<U128>

impl Contract

pub fn do_native_withdraw(withdraw: NativeWithdraw) -> Promise

impl Contract

pub fn do_storage_deposit(storage_deposit: StorageDeposit) -> Promise

impl Contract

pub fn do_ft_withdraw(withdraw: FtWithdraw) -> Promise

impl Contract

pub fn nft_resolve_deposit( &mut self, receiver_id: AccountId, contract_id: AccountId, nft_token_id: TokenId, ) -> PromiseOrValue<bool>

impl Contract

pub fn do_nft_withdraw(withdraw: NftWithdraw) -> Promise

impl Contract

pub fn mt_resolve_deposit( &mut self, receiver_id: AccountId, contract_id: AccountId, tokens: Vec<TokenId>, amounts: Vec<U128>, ) -> PromiseOrValue<Vec<U128>>

impl Contract

pub fn do_mt_withdraw(withdraw: MtWithdraw) -> Promise

impl Contract

pub fn resolve_deposit_internal<'a, I>( &mut self, receiver_id: &AccountIdRef, tokens: I, )

where I: IntoIterator<Item = (TokenId, &'a mut u128)>, I::IntoIter: ExactSizeIterator,

impl Contract

pub fn ext(account_id: AccountId) -> ContractExt

API for calling this contract’s functions in a subsequent execution.

pub fn ext_on(promise: Promise) -> ContractExt

impl Contract

pub fn contract_source_metadata()

impl Contract

pub fn new(config: DefuseConfig) -> Contract

Trait Implementations

impl AccessControllable for Contract

fn acl_storage_prefix() -> &'static [u8]

Returns the storage prefix for collections related to access control. By default b"__acl" is used.

fn acl_init_super_admin(&mut self, account_id: AccountId) -> bool

Adds account_id as super-admin without checking any permissions in case there are no super-admins. If there is already a super-admin, it has no effect. This function can be used to add a super-admin during contract initialization. Moreover, it may provide a recovery mechanism if (mistakenly) all super-admins have been removed.

fn acl_add_super_admin(&mut self, account_id: AccountId) -> Option<bool>

Adds account_id as super-admin provided that the predecessor has sufficient permissions, i.e. is a super-admin as defined by [acl_is_super_admin]. To add the first super-admin, [acl_init_super_admin] can be used.

fn acl_role_variants(&self) -> Vec<&'static str>

Returns the names of all variants of the enum that represents roles.

fn acl_is_super_admin(&self, account_id: AccountId) -> bool

Returns whether account_id is a super-admin. A super-admin has admin permissions for every role. However, a super-admin is not considered grantee of any role.

fn acl_revoke_super_admin(&mut self, account_id: AccountId) -> Option<bool>

Revoke super-admin permissions from account_id provided that the predecessor has sufficient permissions, i.e. is a super-admin as defined by [acl_is_super_admin]. This means a super-admin may revoke super-admin permissions from any other super-admin.

fn acl_transfer_super_admin(&mut self, account_id: AccountId) -> Option<bool>

Transfer super-admin permissions from the predecessor to account_id provided that the predecessor has sufficient permissions, i.e. is a super-admin as defined by [acl_is_super_admin]. This function allows a super-admin to revoke the permission from themselves and add account_id as super-admin. While it is a helper for use cases which require this transfer, it should be noted that AccessControllable allows having more than one super-admin.

fn acl_add_admin(&mut self, role: String, account_id: AccountId) -> Option<bool>

Makes account_id an admin provided that the predecessor has sufficient permissions, i.e. is an admin as defined by [acl_is_admin].

fn acl_is_admin(&self, role: String, account_id: AccountId) -> bool

Returns whether account_id is an admin for role. Super-admins are admins for every role.

fn acl_revoke_admin( &mut self, role: String, account_id: AccountId, ) -> Option<bool>

Revokes admin permissions for role from account_id provided that the predecessor has sufficient permissions, i.e. is an admin as defined by [acl_is_admin]. This means an admin for role may revoke admin permissions from any other account that is admin for role.

fn acl_renounce_admin(&mut self, role: String) -> bool

Revokes admin permissions for role from the predecessor. Returns whether the predecessor was an admin for role.

fn acl_revoke_role( &mut self, role: String, account_id: AccountId, ) -> Option<bool>

Revokes role from account_id provided that the predecessor has sufficient permissions, i.e. is an admin as defined by [acl_is_admin].

fn acl_renounce_role(&mut self, role: String) -> bool

Revokes role from the predecessor and returns whether it was a grantee of role.

fn acl_grant_role( &mut self, role: String, account_id: AccountId, ) -> Option<bool>

Grants role to account_id provided that the predecessor has sufficient permissions, i.e. is an admin as defined by [acl_is_admin].

fn acl_has_role(&self, role: String, account_id: AccountId) -> bool

Returns whether account_id has been granted role. Note that adding an account as (super-)admin for role does not make that account a grantee of role. Instead, role has to be granted explicitly.

fn acl_has_any_role(&self, roles: Vec<String>, account_id: AccountId) -> bool

Returns whether account_id has been granted any of the roles.

fn acl_get_super_admins(&self, skip: u64, limit: u64) -> Vec<AccountId>

Enables paginated retrieval of super-admins. It returns up to limit super-admins and skips the first skip super-admins.

fn acl_get_admins(&self, role: String, skip: u64, limit: u64) -> Vec<AccountId>

Enables paginated retrieval of admins of role. It returns up to limit admins and skips the first skip admins.

fn acl_get_grantees( &self, role: String, skip: u64, limit: u64, ) -> Vec<AccountId>

Enables paginated retrieval of grantees of role. It returns up to limit grantees and skips the first skip grantees.

fn acl_get_permissioned_accounts(&self) -> PermissionedAccounts

Convenience method that returns all [PermissionedAccounts].

impl AccountManager for Contract

fn has_public_key(&self, account_id: &AccountId, public_key: &PublicKey) -> bool

Check if account has given public key

fn public_keys_of(&self, account_id: &AccountId) -> HashSet<PublicKey>

Returns set of public keys registered for given account

fn add_public_key(&mut self, public_key: PublicKey)

Registers or re-activates public_key under the caller account_id.

fn remove_public_key(&mut self, public_key: PublicKey)

Deactivate public_key from the caller account_id, i.e. this key can’t be used to make any actions unless it’s re-created.

fn is_nonce_used(&self, account_id: &AccountId, nonce: AsBase64<Nonce>) -> bool

Returns whether given nonce was already used by the account NOTE: nonces are non-sequential and follow permit2 nonce schema.

fn is_auth_by_predecessor_id_enabled(&self, account_id: &AccountId) -> bool

Returns whether authentication by PREDECESSOR_ID is enabled for given account_id.

fn disable_auth_by_predecessor_id(&mut self)

Disables authentication by PREDECESSOR_ID for the caller, i.e. PREDECESSOR_ID itself.

impl BorshDeserialize for Contract

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for Contract

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl ContractState for Contract

fn state_key() -> &'static [u8]

fn state_exists() -> bool

fn state_read() -> Option<Self>

where Self: BorshDeserialize,

fn state_write(&self) -> bool

where Self: BorshSerialize,

impl ControllerUpgradable for Contract

fn upgrade( &mut self, code: Vec<u8>, state_migration_gas: Option<Gas>, ) -> Promise

Requires 1yN attached for security purposes

fn state_migrate(&mut self)

MUST be #[private]

impl Default for Contract

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Contract

type Target = ContractStorage

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Contract

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl FeesManager for Contract

fn set_fee(&mut self, fee: Pips)

Set fees for both token_in and token_out

fn fee(&self) -> Pips

fn set_fee_collector(&mut self, fee_collector: AccountId)

fn fee_collector(&self) -> &AccountId

impl ForceAccountManager for Contract

fn is_account_locked(&self, account_id: &AccountId) -> bool

Returns whether the givenaccount_id is locked

fn force_lock_account(&mut self, account_id: AccountId) -> bool

Locks given account_id from modifying its own state, including token balances. Returns false if the account was already in locked state.

fn force_unlock_account(&mut self, account_id: &AccountId) -> bool

Unlocks given account_id. Returns false if the account wasn’t in locked state.

fn force_disable_auth_by_predecessor_ids(&mut self, account_ids: Vec<AccountId>)

Disables authentication by PREDECESSOR_ID for given account ids.

fn force_enable_auth_by_predecessor_ids(&mut self, account_ids: Vec<AccountId>)

Enables authentication by PREDECESSOR_ID for given account ids.

fn force_add_public_keys( &mut self, public_keys: HashMap<AccountId, HashSet<PublicKey>>, )

Registers or re-activates public_key under the user account_id.

fn force_remove_public_keys( &mut self, public_keys: HashMap<AccountId, HashSet<PublicKey>>, )

Deactivate public_key from the user account_id, i.e. this key can’t be used to make any actions unless it’s re-created.

impl FullAccessKeys for Contract

fn add_full_access_key(&mut self, public_key: PublicKey) -> Promise

fn delete_key(&mut self, public_key: PublicKey) -> Promise

impl FungibleTokenForceWithdrawer for Contract

fn ft_force_withdraw( &mut self, owner_id: AccountId, token: AccountId, receiver_id: AccountId, amount: U128, memo: Option<String>, msg: Option<String>, ) -> PromiseOrValue<U128>

impl FungibleTokenReceiver for Contract

fn ft_on_transfer( &mut self, sender_id: AccountId, amount: U128, msg: String, ) -> PromiseOrValue<U128>

Deposit fungible tokens.

msg contains [AccountId] of the internal recipient. Empty msg means deposit to sender_id

impl FungibleTokenWithdrawResolver for Contract

fn ft_resolve_withdraw( &mut self, token: AccountId, sender_id: AccountId, amount: U128, is_call: bool, ) -> U128

impl FungibleTokenWithdrawer for Contract

fn ft_withdraw( &mut self, token: AccountId, receiver_id: AccountId, amount: U128, memo: Option<String>, msg: Option<String>, ) -> PromiseOrValue<U128>

Returns number of tokens were successfully withdrawn.

impl GarbageCollector for Contract

fn cleanup_nonces(&mut self, nonces: Vec<(AccountId, Vec<AsBase64<Nonce>>)>)

Clears all expired nonces for given accounts by its prefix. Omitting any errors, e.g. if account doesn’t exist or nonces are not expired. NOTE: MUST attach 1 yⓃ for security purposes.

impl ImtBurner for Contract

fn imt_burn( &mut self, minter_id: AccountId, tokens: ImtTokens, memo: Option<String>, )

Burn a set of imt tokens, within the intents contract

impl Intents for Contract

fn execute_intents(&mut self, signed: Vec<MultiPayload>)

fn simulate_intents(&self, signed: Vec<MultiPayload>) -> SimulationOutput

impl MultiTokenCore for Contract

fn mt_transfer( &mut self, receiver_id: AccountId, token_id: TokenId, amount: U128, approval: Option<(AccountId, u64)>, memo: Option<String>, )

fn mt_batch_transfer( &mut self, receiver_id: AccountId, token_ids: Vec<TokenId>, amounts: Vec<U128>, approvals: Option<Vec<Option<(AccountId, u64)>>>, memo: Option<String>, )

fn mt_transfer_call( &mut self, receiver_id: AccountId, token_id: TokenId, amount: U128, approval: Option<(AccountId, u64)>, memo: Option<String>, msg: String, ) -> PromiseOrValue<Vec<U128>>

fn mt_batch_transfer_call( &mut self, receiver_id: AccountId, token_ids: Vec<TokenId>, amounts: Vec<U128>, approvals: Option<Vec<Option<(AccountId, u64)>>>, memo: Option<String>, msg: String, ) -> PromiseOrValue<Vec<U128>>

fn mt_token(&self, token_ids: Vec<TokenId>) -> Vec<Option<Token>>

fn mt_balance_of(&self, account_id: AccountId, token_id: TokenId) -> U128

fn mt_batch_balance_of( &self, account_id: AccountId, token_ids: Vec<TokenId>, ) -> Vec<U128>

fn mt_supply(&self, token_id: TokenId) -> Option<U128>

fn mt_batch_supply(&self, token_ids: Vec<TokenId>) -> Vec<Option<U128>>

impl MultiTokenEnumeration for Contract

fn mt_tokens(&self, from_index: Option<U128>, limit: Option<u32>) -> Vec<Token>

Get a list of all tokens

fn mt_tokens_for_owner( &self, account_id: AccountId, from_index: Option<U128>, limit: Option<u32>, ) -> Vec<Token>

Get list of all tokens owned by a given account

impl MultiTokenForcedCore for Contract

fn mt_force_transfer( &mut self, owner_id: AccountId, receiver_id: AccountId, token_id: TokenId, amount: U128, approval: Option<(AccountId, u64)>, memo: Option<String>, )

fn mt_force_batch_transfer( &mut self, owner_id: AccountId, receiver_id: AccountId, token_ids: Vec<TokenId>, amounts: Vec<U128>, approvals: Option<Vec<Option<(AccountId, u64)>>>, memo: Option<String>, )

fn mt_force_transfer_call( &mut self, owner_id: AccountId, receiver_id: AccountId, token_id: TokenId, amount: U128, approval: Option<(AccountId, u64)>, memo: Option<String>, msg: String, ) -> PromiseOrValue<Vec<U128>>

fn mt_force_batch_transfer_call( &mut self, owner_id: AccountId, receiver_id: AccountId, token_ids: Vec<TokenId>, amounts: Vec<U128>, approvals: Option<Vec<Option<(AccountId, u64)>>>, memo: Option<String>, msg: String, ) -> PromiseOrValue<Vec<U128>>

impl MultiTokenForcedWithdrawer for Contract

fn mt_force_withdraw( &mut self, owner_id: AccountId, token: AccountId, receiver_id: AccountId, token_ids: Vec<TokenId>, amounts: Vec<U128>, memo: Option<String>, msg: Option<String>, ) -> PromiseOrValue<Vec<U128>>

impl MultiTokenReceiver for Contract

fn mt_on_transfer( &mut self, sender_id: AccountId, previous_owner_ids: Vec<AccountId>, token_ids: Vec<TokenId>, amounts: Vec<U128>, msg: String, ) -> PromiseOrValue<Vec<U128>>

Deposit multi-tokens.

msg contains [AccountId] of the internal recipient. Empty msg means deposit to sender_id

impl MultiTokenResolver for Contract

fn mt_resolve_transfer( &mut self, previous_owner_ids: Vec<AccountId>, receiver_id: AccountId, token_ids: Vec<TokenId>, amounts: Vec<U128>, approvals: Option<Vec<Option<Vec<ClearedApproval>>>>, ) -> Vec<U128>

impl MultiTokenWithdrawResolver for Contract

fn mt_resolve_withdraw( &mut self, token: AccountId, sender_id: AccountId, token_ids: Vec<TokenId>, amounts: Vec<U128>, is_call: bool, ) -> Vec<U128>

impl MultiTokenWithdrawer for Contract

fn mt_withdraw( &mut self, token: AccountId, receiver_id: AccountId, token_ids: Vec<TokenId>, amounts: Vec<U128>, memo: Option<String>, msg: Option<String>, ) -> PromiseOrValue<Vec<U128>>

Returns number of tokens were successfully withdrawn

impl NonFungibleTokenForceWithdrawer for Contract

fn nft_force_withdraw( &mut self, owner_id: AccountId, token: AccountId, receiver_id: AccountId, token_id: TokenId, memo: Option<String>, msg: Option<String>, ) -> PromiseOrValue<bool>

impl NonFungibleTokenReceiver for Contract

fn nft_on_transfer( &mut self, sender_id: AccountId, previous_owner_id: AccountId, token_id: TokenId, msg: String, ) -> PromiseOrValue<bool>

Deposit non-fungible token.

msg contains [AccountId] of the internal recipient. Empty msg means deposit to sender_id

impl NonFungibleTokenWithdrawResolver for Contract

fn nft_resolve_withdraw( &mut self, token: AccountId, sender_id: AccountId, token_id: TokenId, is_call: bool, ) -> bool

impl NonFungibleTokenWithdrawer for Contract

fn nft_withdraw( &mut self, token: AccountId, receiver_id: AccountId, token_id: TokenId, memo: Option<String>, msg: Option<String>, ) -> PromiseOrValue<bool>

Returns number of tokens were successfully withdrawn

impl Pausable for Contract

fn pa_storage_key(&self) -> &'static [u8]

Returns the key of the storage slot which contains the list of features that are paused. By default b"__PAUSED__" is used.

fn pa_is_paused(&self, key: String) -> bool

Returns whether feature key is paused.

fn pa_all_paused(&self) -> Option<HashSet<String>>

Returns all features that are currently paused.

fn pa_pause_feature(&mut self, key: String) -> bool

Pauses feature key. This method fails if the caller has not been granted one of the access control pause_roles passed to the Pausable plugin.

fn pa_unpause_feature(&mut self, key: String) -> bool

Unpauses feature key. This method fails if the caller has not been granted one of the access control unpause_roles passed to the Pausable plugin.

impl RelayerKeys for Contract

fn add_relayer_key(&mut self, public_key: PublicKey) -> Promise

Adds access key for calling execute_signed_intents with allowance passed as attached deposit via #[payable] NOTE: requires 1yN for security purposes

fn do_add_relayer_key(&mut self, public_key: PublicKey)

fn delete_relayer_key(&mut self, public_key: PublicKey) -> Promise

NOTE: requires 1yN for security purposes

impl SaltManager for Contract

fn update_current_salt(&mut self) -> Salt

Sets the current salt to a new one, previous salt remains valid. Returns the new current salt.

fn invalidate_salts(&mut self, salts: Vec<Salt>) -> Salt

Invalidates the provided salt: invalidates provided salt, sets a new one if it was current salt. Returns the current salt.

fn is_valid_salt(&self, salt: Salt) -> bool

Returns whether the provided salt is valid

fn current_salt(&self) -> Salt

Returns the current salt

impl State for Contract

fn add_public_key( &mut self, account_id: AccountId, public_key: PublicKey, ) -> Result<()>

fn remove_public_key( &mut self, account_id: AccountId, public_key: PublicKey, ) -> Result<()>

fn commit_nonce(&mut self, account_id: AccountId, nonce: Nonce) -> Result<()>

fn cleanup_nonce_by_prefix( &mut self, account_id: &AccountIdRef, prefix: NoncePrefix, ) -> Result<bool>

fn internal_add_balance( &mut self, owner_id: AccountId, tokens: impl IntoIterator<Item = (TokenId, u128)>, ) -> Result<()>

fn internal_sub_balance( &mut self, owner_id: &AccountIdRef, tokens: impl IntoIterator<Item = (TokenId, u128)>, ) -> Result<()>

fn ft_withdraw( &mut self, owner_id: &AccountIdRef, withdraw: FtWithdraw, ) -> Result<()>

fn nft_withdraw( &mut self, owner_id: &AccountIdRef, withdraw: NftWithdraw, ) -> Result<()>

fn mt_withdraw( &mut self, owner_id: &AccountIdRef, withdraw: MtWithdraw, ) -> Result<()>

fn native_withdraw( &mut self, owner_id: &AccountIdRef, withdraw: NativeWithdraw, ) -> Result<()>

fn notify_on_transfer( &self, sender_id: &AccountIdRef, receiver_id: AccountId, tokens: Amounts, notification: NotifyOnTransfer, )

fn storage_deposit( &mut self, owner_id: &AccountIdRef, storage_deposit: StorageDeposit, ) -> Result<()>

fn set_auth_by_predecessor_id( &mut self, account_id: AccountId, enable: bool, ) -> Result<bool>

Sets whether authentication by PREDECESSOR_ID is enabled. Returns whether authentication by PREDECESSOR_ID was enabled before.

fn auth_call( &mut self, signer_id: &AccountIdRef, auth_call: AuthCall, ) -> Result<()>

fn mint( &mut self, owner_id: AccountId, tokens: Amounts, memo: Option<String>, ) -> Result<()>

fn burn( &mut self, owner_id: &AccountIdRef, tokens: Amounts, memo: Option<String>, ) -> Result<()>

fn internal_apply_deltas( &mut self, owner_id: &AccountIdRef, tokens: impl IntoIterator<Item = (TokenId, i128)>, ) -> Result<(), DefuseError>

fn imt_mint( &mut self, minter_id: &AccountIdRef, receiver_id: AccountId, tokens: Amounts<BTreeMap<String, u128>>, memo: Option<String>, notification: Option<NotifyOnTransfer>, ) -> Result<(), DefuseError>

fn imt_burn( &mut self, owner_id: &AccountIdRef, minter_id: &AccountIdRef, tokens: Amounts<BTreeMap<String, u128>>, memo: Option<String>, ) -> Result<(), DefuseError>

impl StateView for Contract

fn verifying_contract(&self) -> Cow<'_, AccountIdRef>

fn wnear_id(&self) -> Cow<'_, AccountIdRef>

fn fee(&self) -> Pips

fn fee_collector(&self) -> Cow<'_, AccountIdRef>

fn has_public_key( &self, account_id: &AccountIdRef, public_key: &PublicKey, ) -> bool

fn iter_public_keys( &self, account_id: &AccountIdRef, ) -> impl Iterator<Item = PublicKey> + '_

fn is_nonce_used(&self, account_id: &AccountIdRef, nonce: Nonce) -> bool

fn balance_of(&self, account_id: &AccountIdRef, token_id: &TokenId) -> u128

fn is_account_locked(&self, account_id: &AccountIdRef) -> bool

fn is_auth_by_predecessor_id_enabled(&self, account_id: &AccountIdRef) -> bool

Returns whether authentication by PREDECESSOR_ID is enabled.

fn is_valid_salt(&self, salt: Salt) -> bool

Returns whether salt in nonce is valid

fn wnear_token_id(&self) -> TokenId

fn cached(self) -> CachedState<Self>

where Self: Sized,

impl Defuse for Contract