Module imports

Imports normally needed in integration tests, grouped together.

Re-exports

pub use crate::api::DebugApi;

pub use crate::api::DebugHandle;

pub use crate::api::StaticApi;

pub use crate::bech32;

pub use crate::scenario::model::Account;

pub use crate::scenario::model::AddressValue;

pub use crate::scenario::model::BytesValue;

pub use crate::scenario::model::CheckAccount;

pub use crate::scenario::model::CheckStateStep;

pub use crate::scenario::model::ScCallStep;

pub use crate::scenario::model::ScDeployStep;

pub use crate::scenario::model::ScQueryStep;

pub use crate::scenario::model::Scenario;

pub use crate::scenario::model::SetStateStep;

pub use crate::scenario::model::TransferStep;

pub use crate::scenario::model::TxESDT;

pub use crate::scenario::model::TxExpect;

pub use crate::scenario::model::TypedResponse;

pub use crate::scenario::model::TypedScDeploy;

pub use crate::scenario::ScenarioRunner;

pub use crate::ScenarioTxRun;

pub use crate::num_bigint;

pub use crate::whitebox_legacy::*;

Modules

call_value_init

err_msg

heap

system_proxy

Macros

assert_values_eq

managed_address

managed_biguint

managed_buffer

managed_token_id

non_zero_usize

Converts usize to NonZeroUsize or returns SCError.

require

Allows us to write Solidity style require!(<condition>, <error_msg>) and avoid if statements.

rust_biguint

sc_format

sc_panic

sc_print

Structs

Address

An Address is just a H256 with a different name. Has a different ABI name than H256.

AddressToIdMapper

AnnotatedEgldPayment

ApiOutputAdapter

ArgBuffer

Helper structure for providing arguments to all SC call functions other than async_call_raw. It keeps argument lengths separately from the argument data itself. Argument data is concatenated into a single byte buffer.

ArgDecodeInput

Adapter from the API to the TopDecodeInput trait. Allows objects to be deserialized directly from the API as arguments.

ArgErrorHandler

ArgId

Some info to display in endpoint argument deserialization error messages, to help users identify the faulty argument. Generated automatically. Current version uses argument names, but in principle it could be changed to argument index to save some bytes from the wasm output.

ArrayVec

A vector with a fixed capacity.

AsyncCallError

AsyncCallPromisesDeprecated

Will be renamed to AsyncCall and AsyncCall to AsyncCallLegacy when the promises end up on the mainnet.

BackTransfers

Holding back-transfer data, as retrieved from the VM.

Bech32Address

Wraps and address, and presents it as a bech32 expression wherever possible.

BiDiMapper

A bi-directional map, from values to ids and viceversa. The mapper is based on UnorderedSetMapper, reason why the remove is done by swap_remove

BigFloat

BigInt

BigUint

Box

A pointer type that uniquely owns a heap allocation of type T.

BoxedBytes

Simple wrapper around a boxed byte slice, but with a lot of optimized methods for manipulating it. The focus is on reducing code size rather improving speed.

BytesArgLoader

Consumes a vector of BoxedBytes and deserializes from the vector one by one.

CallbackClosure

Object that encodes full async callback data.

CallbackClosureForDeser

Similar object to CallbackClosure, but only used for deserializing from storage the callback data with the old async call mechanism.

CallbackClosureMatcher

Helps the callback macro expansion to perform callback name matching more efficiently. The current implementation hashes by callback name length, but in principle further optimizations are possible.

Code

Contains code for a deploy or upgrade.

CodeMetadata

ConsNoRet

Handlers that return nothing.

ConsRet

ConstDecimals

Zero-sized constant number of decimals.

ContractCallNoPaymentDeprecated

Holds metadata for calling another contract, without payments.

ContractCallWithAnyPaymentDeprecated

Holds data for calling another contract, with any type of payment: none, EGLD, Multi-ESDT.

ContractCallWithEgldDeprecated

Holds data for calling another contract, with EGLD payment only.

ContractCallWithEgldOrSingleEsdtDeprecated

Holds data for calling another contract, with a single payment, either EGLD or a single ESDT token.

ContractCallWithMultiEsdtDeprecated

ContractDeployDeprecated

ContractInfo

Bundles a representation of a contract with the contract proxy, so that it can be easily called in the context of a blockchain mock.

DecodeError

DeployCall

Holds deploy data: code, code metadata, and arguments.

DeployRawResult

ESDTSystemSCAddress

Indicates the system SC address, which is the same on any MultiversX blockchain.

ESDTSystemSCProxy

Proxy for the ESDT system smart contract.

ESDTSystemSCProxyMethods

Method container of the ESDT system smart contract proxy.

ESDTSystemSmartContractProxyDeprecated

Proxy for the ESDT system smart contract. Unlike other contract proxies, this one has a fixed address, so the proxy object doesn’t really contain any data, it is more of a placeholder.

Egld

Indicates the EGLD payment in a transaction.

EgldOrEsdtTokenIdentifier

Specialized type for handling either EGLD or ESDT token identifiers.

EgldOrEsdtTokenPayment

EgldOrEsdtTokenPaymentMultiValue

Thin wrapper around EgldOrEsdtTokenPayment, which has different I/O behaviour:

EgldOrEsdtTokenPaymentRefs

Similar to EgldOrEsdtTokenPayment, but only contains references.

EllipticCurve

Empty

Empty structure with an empty bytes representation. Equivalent to false, 0 or [u8; 0], but more explicit.

EsdtLocalRoleFlags

EsdtTokenData

EsdtTokenPayment

EsdtTokenPaymentMultiValue

Thin wrapper around EsdtTokenPayment, which has different I/O behaviour:

EsdtTokenPaymentRefs

The version of EsdtTokenPayment that contains referrences instead of owned fields.

ExpectError

Verifies that transaction result error matches the given one.

ExpectMessage

Verifies that transaction result message matches the given one.

ExpectStatus

Verifies that transaction result status matches the given one.

ExpectValue

Verifies that transaction result matches the given value.

ExplicitGas

FilePath

FromSource

Indicates the source of a “deploy from source” or “upgrade from source”.

FullPaymentData

FunctionCall

Encodes a function call on the blockchain, composed of a function name and its encoded arguments.

FungibleTokenMapper

FungibleTokenProperties

GasLeft

Indicates that all remaining gas should be sent to a transaction.

H256

Type that holds 32 bytes of data. Data is kept on the heap to keep wasm size low and avoid copies.

IgnoreValue

Structure that allows taking a variable number of arguments, but does nothing with them, not even deserialization.

InterpreterContext

LinkedListMapper

LinkedListNode

LockableStaticBuffer

ManagedAddress

ManagedArgBuffer

ManagedAsyncCallError

ManagedBuffer

A byte buffer managed by an external API.

ManagedBufferBuilder

ManagedBufferBuilderImplBasic

Basic implementation of a ManagedBuffer builder, no caching.

ManagedBufferBuilderImplCached

A ManagedBuffer builder implementation that caches data to the static cache locally in the contract.

ManagedBufferNestedDecodeInput

Nested decode buffer based on a managed buffer. Uses the load/copy slice API to extract pieces of the managed buffer for deserialization.

ManagedBufferReadToEnd

A wrapper over a ManagedBuffer with different decode properties. It reads until the end of the buffer.

ManagedByteArray

A list of items that lives inside a managed buffer. Items can be either stored there in full (e.g. u32), or just via handle (e.g. BigUint<M>).

ManagedDecimal

Fixed-point decimal numbers that accept either a constant or variable number of decimals.

ManagedDecimalSigned

Fixed-point decimal numbers that accept either a constant or variable number of decimals.

ManagedMap

A byte buffer managed by an external API.

ManagedMapEncoded

A managed map that works with any serializable key and value types.

ManagedOption

A very efficient optional managed type.

ManagedRef

A very efficient reference to a managed type, with copy semantics.

ManagedRefMut

A very efficient mutable reference to a managed type.

ManagedSCError

Smart contract error that can concatenate multiple message pieces. The message is kept as a managed buffer in the VM.

ManagedVec

A list of items that lives inside a managed buffer. Items can be either stored there in full (e.g. u32), or just via handle (e.g. BigUint<M>).

ManagedVecItemEmptyPayload

Empty ManagedVecItem.

ManagedVecItemPayloadBuffer

The main ManagedVecItemPayload implementation. Uses an array in its implementation.

ManagedVecOwnedIterator

ManagedVecPayloadIterator

ManagedVecRef

ManagedVecRefIterator

ManagedVecRefMut

MapMapper

MapStorageMapper

MetaTokenProperties

MultiValue2

MultiValue3

MultiValue4

MultiValue5

MultiValue6

MultiValue7

MultiValue8

MultiValue9

MultiValue10

MultiValue11

MultiValue12

MultiValue13

MultiValue14

MultiValue15

MultiValue16

MultiValueEncoded

A multi-value container, that keeps raw values as ManagedBuffer It allows encoding and decoding of multi-values.

MultiValueEncodedCounted

A multi-value container, that keeps raw values as ManagedBuffer, and which encodes and decodes its length explicitly.

MultiValueEncodedIterator

Iterator for MultiValueEncoded and MultiValueEncodedCounted.

MultiValueManagedVec

MultiValueManagedVecCounted

Argument or result that is made up of the argument count, followed by the arguments themselves. Think of it as a VarArgs preceded by the count. Unlike MultiValueManagedVec it deserializes eagerly.

MultiValueVec

Structure that allows taking a variable number of arguments or returning a variable number of results in a smart contract endpoint.

MxscPath

NonFungibleTokenMapper

NonFungibleTokenProperties

NonZeroUsizeIterator

Iterator that can give us a range of NonZeroUsize.

NotPayable

Transaction marker, which indicates that a transaction should never have any payment added to it.

NumExpr

OrderedBinaryTreeMapper

OrderedBinaryTreeNode

OriginalResultMarker

Contains no data.

PassValue

Simply passes a value to the result.

PlaceholderInput

Temporary value used for any kind of templates.

PlaceholderOutput

Temporary value used for any kind of templates.

Queue

A simple queue struct that is able to push and pop without moving elements. New items are pushed at the end, just like for a regular Vec. When popping, instead of performing a regular Vec remove that would shift items, a start index is moved up 1 position. When serializing, items before the start index are ignored.

QueueMapper

A queue with owned nodes.

RandomnessSource

ReturnsBackTransfers

Indicates that back-transfers will be returned.

ReturnsBackTransfersEGLD

Indicates that back-transfers will be returned.

ReturnsBackTransfersMultiESDT

Indicates that back-transfers will be returned.

ReturnsBackTransfersSingleESDT

Indicates that back-transfers will be returned.

ReturnsGasUsed

Indicates that the newly deployed address will be returned after a deploy.

ReturnsHandledOrError

Indicates that a Result will be returned, either with the handled result, according to the nested result handlers, or with an error in case of a failed transaction.

ReturnsLogs

ReturnsMessage

Indicates that the error status will be returned.

ReturnsNewAddress

Indicates that the newly deployed address will be returned after a deploy.

ReturnsNewBech32Address

Indicates that the newly deployed address will be returned after a deploy.

ReturnsNewManagedAddress

Indicates that the newly deployed address will be returned after a deploy as a ManagedAddress.

ReturnsNewTokenIdentifier

ReturnsRawResult

Indicates that the raw result data will be returned.

ReturnsResult

Indicates that result will be returned.

ReturnsResultAs

Indicates that result will be returned.

ReturnsResultUnmanaged

Indicates that the unmanaged version of the result will be returned.

ReturnsStatus

Indicates that the error status will be returned.

ReturnsTxHash

RustBigInt

A big signed integer type.

RustBigUint

A big unsigned integer type.

ScenarioEnvExec

Environment for executing transactions.

ScenarioEnvQuery

ScenarioTxEnvData

The actual data required to run a scenario locally. This is the minimal environment needed to run txs.

ScenarioWorld

A facade for contracts tests.

SemiFungibleTokenProperties

SetMapper

SingleValue

Intermediary type for deserializing the result of an endpoint that returns a SingleValueMapper.

SingleValueMapper

Manages a single serializable item in storage.

SparseArray

A special type of array that initially holds the values from 0 to N If array[i] == i, then the default value (0) is stored instead

SparseArrayIterator

StaticBufferRef

StaticSCError

Contains a smart contract execution error message.

String

A UTF-8–encoded, growable string.

SyncCallRawResult

TestAddress

Encodes a dummy address, to be used for tests.

TestEsdtTransfer

Syntactic sugar for quickly writing ESDT transfers in tests.

TestSCAddress

Encodes a dummy SC address, to be used for tests.

TestTokenIdentifier

Encodes a dummy address, to be used for tests.

ToCaller

Indicates that transaction should be sent to the caller (the sender of the current transaction).

ToSelf

Indicates that transaction should be sent to itself.

TokenAttributesMapper

TokenIdentifier

Specialized type for handling token identifiers. It wraps a BoxedBytes with the full ASCII name of the token. EGLD is stored as an empty name.

TokenProperties

TokenPropertyArguments

Represents property arguments to be sent to the system SC.

Tx

Universal representation of a blockchain transaction.

TxScEnv

The transaction environment used in calls launched from a SC.

TypedFunctionCallDeprecated

Old attempt at grouping FunctionCall + OriginalTypeMarker.

UniqueIdMapper

Holds the values from 1 to N with as little storage interaction as possible If Mapper[i] = i, then it stores nothing, i.e. “0” If Mapper[i] is equal to another value, then it stores the value

UnorderedSetMapper

UpgradeCall

Holds deploy data: code, code metadata, and arguments.

UserBuiltinProxy

Proxy describing the user builtin function signatures.

UserBuiltinProxyMethods

UserMapper

Very widely used mapper, that manages the users of a smart contract. It holds a bi-directional map, from addresses to ids and viceversa. This is so we can easily iterate over all users, using their ids. Also holds the user count in sync. This is also necessary for iteration.

Vec

A contiguous growable array type, written as Vec<T>, short for ‘vector’.

VecMapper

Manages a list of items of the same type. Saves each of the items under a separate key in storage. To produce each individual key, it concatenates the main key with a serialized 4-byte index. Indexes start from 1, instead of 0. (We avoid 0-value indexes to prevent confusion between an uninitialized variable and zero.) It also stores the count separately, at what would be index 0. The count is always kept in sync automatically.

WhiteboxContract

Wraps a contract that is supposed to be used in whitebox tests.

WhitelistMapper

A non-iterable whitelist mapper. Very efficient for storing a whitelist, as each item requires only one storage key. If you need to iterate over the keys, use UnorderedSetMapper or SetMapper instead.

WithNewAddress

Defines a lambda function to be called on the newly deployed address, after a deploy.

WithRawResult

Defines a lambda function to be called on the raw result of the transaction.

WithRawTxResponse

Wraps a closure that handles a TxResponse object.

WithResult

Defines a lambda function to be called on the decoded result.

WithResultAs

Defines a lambda function to be called on the decoded result.

Enums

AsyncCallResult

CallbackSelectorResult

Used internally between the callback and callback_selector methods. It is likely to be removed in the future.

EgldOrMultiEsdtPayment

Encodes any type of payment, which either:

EgldOrMultiEsdtPaymentRefs

The version of EgldOrMultiEsdtPayment that contains referrences instead of owned fields.

EsdtLocalRole

EsdtTokenType

ManagedAsyncCallResult

MessageHashType

Message hash type for the verifyCustomSecp256k1 CryptoApi function

OperationCompletionStatus

Standard way of signalling that an operation was interrupted early, before running out of gas. An endpoint that performs a longer operation can check from time to time if it is running low on gas and can decide to save its state and exit, so that it can continue the same operation later.

OptionalValue

A smart contract argument or result that can be missing.

ReturnCode

SCResultDeprecated

Default way to optionally return an error from a smart contract endpoint.

Sign

TokenMapperState

Constants

NULL_ID

NULL_NODE_ID

Traits

Add

The addition operator +.

AddAssign

The addition assignment operator +=.

AnnotatedValue

Describes a value can also have a custom representation in a mandos scenario.

ArgNestedTuple

Models an argument tree of the form (arg1, (arg2, ... (argn, ()))), used for retrieving endpoint arguments.

BitAnd

The bitwise AND operator &.

BitAndAssign

The bitwise AND assignment operator &=.

BitOr

The bitwise OR operator |.

BitOrAssign

The bitwise OR assignment operator |=.

BitXor

The bitwise XOR operator ^.

BitXorAssign

The bitwise XOR assignment operator ^=.

ContractBase

Interface to be used by the actual smart contract code.

ContractCall

Defines a contract call object, which is the basis for all calls to other contracts.

ContractCallBaseDeprecated

Converts into a legacy contract call.

Decimals

Implemented by all decimal types usable in ManagedDecimal.

Div

The division operator /.

DivAssign

The division assignment operator /=.

ErrorApiImpl

ExternallyMergeable

Used when merging is done through an external SC call. Generally, these only need to have the same token ID, with different nonces.

FixedSupplyToken

InterpretableFrom

IntoMultiValue

Defines conversion of a type to its multi-value representation.

ManagedBufferBuilderImpl

ManagedType

Commonalities between all managed types.

ManagedTypeApi

ManagedVecItem

Types that implement this trait can be items inside a ManagedVec. All these types need a payload, i.e a representation that gets stored in the underlying managed buffer. Not all data needs to be stored as payload, for instance for most managed types the payload is just the handle, whereas the mai ndata is kept by the VM.

ManagedVecItemNestedTuple

Syntactic sugar, that allows us to more easily represent composite payloads as nested tuples.

ManagedVecItemPayload

Describes the binary represetnation of a ManagedVecItem.

ManagedVecItemPayloadAdd

Describes concatantion of smaller payloads into a larger one.

Mergeable

Used for types that can be merged locally.

Mul

The multiplication operator *.

MulAssign

The multiplication assignment operator *=.

NestedDecode

Trait that allows zero-copy read of value-references from slices in LE format.

NestedEncode

Trait that allows zero-copy write of value-references to slices in LE format.

ProxyArg

Trait that is automatically implemented for all types that are allowed as proxy inputs.

ProxyObjBase

ProxyObjNew

RHList

RHListAppendNoRet

RHListAppendRet

RHListExec

Indicates how result processing will undergo for an ensemble of result handlers.

RHListItem

Result handler list item.

RHListItemExec

Indicates how result processing will undergo for one specific result handler.

RegisterCodeSource

Used when registering a contract for debugging.

Rem

The remainder operator %.

RemAssign

The remainder assignment operator %=.

SCError

Any type that implements this trait can be used to signal errors when returning from a SC endpoint.

ScenarioTxEnv

Designates a tx environment suitable for running scenarios locally.

ScenarioTxRun

Provides a run method for transactions and steps.

ScenarioTxWhitebox

Shl

The left shift operator <<. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ << _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a << b and a.shl(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.

ShlAssign

The left shift assignment operator <<=.

Shr

The right shift operator >>. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ >> _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a >> b and a.shr(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.

ShrAssign

The right shift assignment operator >>=.

StorageClearable

StorageMapper

StorageMapperFromAddress

Sub

The subtraction operator -.

SubAssign

The subtraction assignment operator -=.

TopDecode

Trait that allows zero-copy read of values from an underlying API in big endian format.

TopEncode

TxAsyncCallCallback

TxCodeSource

TxCodeSourceSpecified

TxCodeValue

TxData

Marks the data field of a transaction in Tx.

TxDataFunctionCall

TxEgldValue

TxEmptyResultHandler

Indicates that given result handler is empty, i.e. doesn’t cause any side effects and returns nothing.

TxEnv

TxEnvMockDeployAddress

TxEnvWithTxHash

TxFrom

Marks the sender of any transaction.

TxFromSourceValue

TxFromSpecified

Marks the non-empty sender of a transaction.

TxGas

All typed that populate the gas field of a transaction need to implement this trait.

TxGasValue

TxNoPayment

Marker trait that indicates that payment field contains no payment.

TxPayment

Describes a payment that is part of a transaction.

TxPaymentEgldOnly

Marks a payment object that only contains EGLD or nothing at all.

TxPaymentMultiEsdt

Indicates that a payment object contains a multi-ESDT payment.

TxPromisesCallback

TxProxyTrait

Defines a proxy object for a smart contract.

TxResultHandler

Marks a general result handler, to be used in the transaction unified syntax.

TxTo

Marks the recipient of any transaction.

TxToSpecified

Marks the non-empty recipient of a transaction.

TypeAbi

Implemented for all types that can end up in the ABI:

VMApi

Functions

check_dep_decode

Calls both the fast exit and the regular dep-decode, compares that the outputs are equal, then returns the result. To be used in serialization tests.

check_dep_encode

Calls both the fast exit and the regular dep-encode, compares that the outputs are equal, then returns the result. To be used in serialization tests.

check_dep_encode_decode

check_top_decode

Calls both the fast exit and the regular top-decode, compares that the outputs are equal, then returns the result. To be used in serialization tests.

check_top_encode

Calls both the fast exit and the regular top-encode, compares that the outputs are equal, then returns the result. To be used in serialization tests.

check_top_encode_decode

dep_decode_from_byte_slice_or_panic

Calls nested decode and panics if an encoding error occurs. Do not use in smart contracts!

dep_encode_to_vec_or_panic

Calls nested encode and panics if an encoding error occurs. Do not use in smart contracts!

finish_multi

load_callback_closure_args

load_endpoint_args

Used for loading all regular endpoint arguments. A call to this gets generated for all endpoints and callbacks.

load_multi_args_custom_loader

Currently used for the callback closure. No distinction there for single values.

managed_vec_item_read_from_payload_index^⚠

Used by the ManagedVecItem derive.

managed_vec_item_save_to_payload_index^⚠

Used by the ManagedVecItem derive.

new_callback_call

Syntactical sugar to help macros to generate code easier. Unlike calling CallbackClosure::<SA, R>::new, here types can be inferred from the context.

new_contract_deploy

Syntactical sugar to help macros to generate code easier. Unlike calling ContractDeploy::<SA>::new, here types can be inferred from the context.

non_zero_usize_from_n_plus_1

This is safe because adding 1 to a positive number makes it greater than one.

non_zero_usize_one

This is safe because 1 != 0.

non_zero_usize_plus

This is safe because adding a non-zero number with a positive one yields a non-zero number.

ser_deser_okDeprecated

backwards compatibility only, will remove in next major release

signal_arg_de_error

top_encode_to_vec_u8_or_panic

Calls top encode and panics if an encoding error occurs. Do not use in smart contracts!

Type Aliases

AddressId

AsyncCallDeprecated

Kept as alias for backwards compatibility.

EgldPayment

EllipticCurveComponents

EsdtTokenPaymentMultiArgDeprecated

IgnoreVarArgsDeprecated

Structure that allows taking a variable number of arguments, but does nothing with them, not even deserialization.

IssueCall

The specific Tx type produces by the issue operations of the ESDTSystemSCProxy.

ManagedBufferCachedBuilderDeprecated

ManagedBufferImplDefault

ManagedCountedMultiResultVecDeprecated

ManagedCountedVarArgsDeprecated

ManagedMultiResultVecDeprecated

ManagedMultiResultVecEagerDeprecated

ManagedVarArgsDeprecated

ManagedVarArgsEagerDeprecated

MultiArg2Deprecated

MultiArg3Deprecated

MultiArg4Deprecated

MultiArg5Deprecated

MultiArg6Deprecated

MultiArg7Deprecated

MultiArg8Deprecated

MultiArg9Deprecated

MultiArg10Deprecated

MultiArg11Deprecated

MultiArg12Deprecated

MultiArg13Deprecated

MultiArg14Deprecated

MultiArg15Deprecated

MultiArg16Deprecated

MultiArgVecDeprecated

Structure that allows taking a variable number of arguments or returning a variable number of results in a smart contract endpoint.

MultiEgldOrEsdtPayment

Alias for a list of payments of EGLD or ESDT tokens.

MultiEsdtPayment

Alias for a list of payments.

MultiResult2Deprecated

MultiResult3Deprecated

MultiResult4Deprecated

MultiResult5Deprecated

MultiResult6Deprecated

MultiResult7Deprecated

MultiResult8Deprecated

MultiResult9Deprecated

MultiResult10Deprecated

MultiResult11Deprecated

MultiResult12Deprecated

MultiResult13Deprecated

MultiResult14Deprecated

MultiResult15Deprecated

MultiResult16Deprecated

MultiResultVecDeprecated

Used for returning a variable number of results from an endpoint, it is synonymous with MultiResult.

NodeId

NumDecimals

Decimals are represented as usize. This type is also used as variable decimals.

OptionalArgDeprecated

A smart contract argument or result that can be missing.

OptionalResultDeprecated

It is just an alias for OptionalArg. In general we use OptionalArg for arguments and OptionalResult for results, but it is the same implementation for both.

TxBaseWithEnv

TxProxyCall

Alias for a Tx generated from a proxy, in an endpoint.

TxProxyDeploy

Alias for a Tx generated from a proxy, in init.

TxProxyUpgrade

Alias for a Tx generated from a proxy, in upgrade.

TxScBase

TxTypedCall

Alias for a Tx generated from a proxy, in an endpoint.

TxTypedDeploy

Alias for a Tx generated from a proxy, in init.

TxTypedUpgrade

Alias for a Tx generated from a proxy, in upgrade.

UniqueId

VarArgsDeprecated

Used for taking a variable number of arguments in an endpoint, it is synonymous with MultiResultVec/MultiArgVec.