multiversx_sdk package

Subpackages

Module contents

class multiversx_sdk.Account(secret_key: UserSecretKey, hrp: str | None = None)[source]

Bases: object

get_nonce_then_increment() → int[source]

classmethod new_from_keypair(keypair: KeyPair) → Account[source]

classmethod new_from_keystore(file_path: Path, password: str, address_index: int | None = None, hrp: str | None = None) → Account[source]

classmethod new_from_mnemonic(mnemonic: str, address_index: int = 0, hrp: str | None = None) → Account[source]

classmethod new_from_pem(file_path: Path, index: int = 0, hrp: str | None = None) → Account[source]

save_to_keystore(path: Path, password: str = '')[source]: Saves the secret key to a keystore file with kind=secretKey.

save_to_pem(path: Path)[source]

sign(data: bytes) → bytes[source]: Signs using the account’s secret key.

sign_message(message: Message) → bytes[source]

sign_transaction(transaction: Transaction) → bytes[source]

verify(data: bytes, signature: bytes) → bool[source]: Verifies the signature using the account’s public key.

class multiversx_sdk.AccountAwaiter(fetcher: IAccountFetcher, polling_interval_in_milliseconds: int | None = None, timeout_interval_in_milliseconds: int | None = None, patience_time_in_milliseconds: int | None = None)[source]

Bases: object

AccountAwaiter allows one to await until a specific event occurs on a given address.

Args:: fetcher (IAccountFetcher): Used to fetch the account of the network. polling_interval_in_milliseconds (Optional[int]): The polling interval, in milliseconds. timeout_interval_in_milliseconds (Optional[int]): The timeout, in milliseconds. patience_time_in_milliseconds (Optional[int]): The patience, an extra time (in milliseconds) to wait, after the account has reached its desired condition.

await_on_condition(address: Address, condition: Callable[[AccountOnNetwork], bool]) → AccountOnNetwork[source]: Waits until the condition is satisfied.

class multiversx_sdk.AccountController(chain_id: str, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseController

create_transaction_for_guarding_account(sender: IAccount, nonce: int, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_saving_key_value(sender: IAccount, nonce: int, key_value_pairs: dict[bytes, bytes], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_guardian(sender: IAccount, nonce: int, guardian_address: Address, service_id: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unguarding_account(sender: IAccount, nonce: int, guardian: Address, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

class multiversx_sdk.AccountOnNetwork(raw: dict[str, Any], address: multiversx_sdk.core.address.Address, nonce: int, balance: int, is_guarded: bool, username: str = '', block_coordinates: multiversx_sdk.network_providers.resources.BlockCoordinates | None = None, contract_code_hash: bytes = b'', contract_code: bytes = b'', contract_developer_reward: int = 0, contract_owner_address: multiversx_sdk.core.address.Address | None = None, is_contract_upgradable: bool = False, is_contract_readable: bool = False, is_contract_payable: bool = False, is_contract_payable_by_contract: bool = False)[source]

Bases: object

address: Address

balance: int

block_coordinates: BlockCoordinates | None = None

contract_code: bytes = b''

contract_code_hash: bytes = b''

contract_developer_reward: int = 0

contract_owner_address: Address | None = None

is_contract_payable: bool = False

is_contract_payable_by_contract: bool = False

is_contract_readable: bool = False

is_contract_upgradable: bool = False

is_guarded: bool

nonce: int

raw: dict[str, Any]

username: str = ''

class multiversx_sdk.AccountStorage(raw: dict[str, Any], entries: list[multiversx_sdk.network_providers.resources.AccountStorageEntry], block_coordinates: multiversx_sdk.network_providers.resources.BlockCoordinates | None = None)[source]

Bases: object

block_coordinates: BlockCoordinates | None = None

entries: list[AccountStorageEntry]

raw: dict[str, Any]

class multiversx_sdk.AccountStorageEntry(raw: dict[str, Any], key: str, value: bytes, block_coordinates: multiversx_sdk.network_providers.resources.BlockCoordinates | None = None)[source]

Bases: object

block_coordinates: BlockCoordinates | None = None

key: str

raw: dict[str, Any]

value: bytes

class multiversx_sdk.AccountTransactionsFactory(config: TransactionsFactoryConfig, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseFactory

create_transaction_for_guarding_account(sender: Address) → Transaction[source]

create_transaction_for_saving_key_value(sender: Address, key_value_pairs: dict[bytes, bytes]) → Transaction[source]

create_transaction_for_setting_guardian(sender: Address, guardian_address: Address, service_id: str) → Transaction[source]

create_transaction_for_unguarding_account(sender: Address, guardian: Address | None = None) → Transaction[source]

class multiversx_sdk.Action[source]

Bases: object

discriminant: int

class multiversx_sdk.ActionFullInfo(action_id: int, group_id: int, action_data: Action, signers: list[Address])[source]: Bases: object

class multiversx_sdk.AddBoardMember(address: Address)[source]

Bases: Action

discriminant: int = 1

class multiversx_sdk.AddProposer(address: Address)[source]

Bases: Action

discriminant: int = 2

class multiversx_sdk.AddQuantityOutcome(token_identifier: str, nonce: int, added_quantity: int)[source]

Bases: object

added_quantity: int

nonce: int

token_identifier: str

class multiversx_sdk.Address(pubkey: bytes, hrp: str | None = None)[source]

Bases: object

An Address, as an immutable object.

Creates an address object, given a sequence of bytes and the human readable part(hrp).

Args:

pubkey (bytes): the sequence of bytes

hrp (str): the human readable part

classmethod empty() → Address[source]: Creates an empty address object. Generally speaking, this should not be used by client code (internal use only).

get_hrp() → str[source]: Returns the human-readable-part of the bech32 address

get_public_key() → bytes[source]: Returns the pubkey as bytes

is_empty() → bool[source]

is_smart_contract() → bool[source]: Returns whether the address is a smart contract address

classmethod new_from_bech32(value: str) → Address[source]

Creates an address object from the bech32 representation of an address.

Args:: value (str): the bech32 address representation

classmethod new_from_hex(value: str, hrp: str | None = None) → Address[source]

Creates an address object from the hexed sequence of bytes and the human readable part(hrp).

Args:

value (str): the sequence of bytes as a hex string

hrp (str): the human readable part

to_bech32() → str[source]: Returns the bech32 representation of the address

to_hex() → str[source]: Returns the hex representation of the address (pubkey)

class multiversx_sdk.AddressComputer(number_of_shards: int = 3)[source]

Bases: object

A class for computing contract addresses and getting shard numbers.

Initializes the AddressComputer with the number of shards.

Args:: number_of_shards (int): The number of shards in the network (default: 3).

compute_contract_address(deployer: Address, deployment_nonce: int) → Address[source]

Computes the contract address based on the deployer’s address and deployment nonce.

Args:

deployer (Address): The address of the deployer

deployment_nonce (int): The nonce of the deployment

Returns:

Address: The computed contract address as below:

8 bytes of zero + 2 bytes for VM type + 20 bytes of hash(owner) + 2 bytes of shard(owner)

get_shard_of_address(address: Address) → int[source]

Returns the shard number of a given address.

Args:: address (Address): The address for which to determine the shard.
Returns:: int: The shard number.

class multiversx_sdk.AddressFactory(hrp: str | None = None)[source]

Bases: object

A factory used to create address objects.

All the addresses created with the factory have the same human readable part

Args:: hrp (str): the human readable part of the address (default: erd)

create_from_bech32(value: str) → Address[source]: Creates an address object from the bech32 representation of an address

create_from_hex(value: str) → Address[source]: Creates an address object from the hexed sequence of bytes

create_from_public_key(pubkey: bytes) → Address[source]: Creates an address object from the sequence of bytes

class multiversx_sdk.ApiNetworkProvider(url: str, address_hrp: str | None = None, config: NetworkProviderConfig | None = None)[source]

Bases: INetworkProvider

await_account_on_condition(address: Address, condition: Callable[[AccountOnNetwork], bool], options: AwaitingOptions | None = None) → AccountOnNetwork[source]: Waits until an account satisfies a given condition.

await_transaction_completed(transaction_hash: str | bytes, options: AwaitingOptions | None = None) → TransactionOnNetwork[source]: Waits until the transaction is completely processed.

await_transaction_on_condition(transaction_hash: str | bytes, condition: Callable[[TransactionOnNetwork], bool], options: AwaitingOptions | None = None) → TransactionOnNetwork[source]: Waits until a transaction satisfies a given condition.

do_get_generic(url: str, url_parameters: dict[str, Any] | None = None) → Any[source]: Does a generic GET request against the network(handles API enveloping).

do_post_generic(url: str, data: Any, url_parameters: dict[str, Any] | None = None) → Any[source]: Does a generic GET request against the network(handles API enveloping).

estimate_transaction_cost(transaction: Transaction) → TransactionCostResponse[source]: Estimates the cost of a transaction.

get_account(address: Address) → AccountOnNetwork[source]: Fetches account information for a given address.

get_account_storage(address: Address) → AccountStorage[source]: Fetches the storage (key-value pairs) of an account. When decoding the keys, the errors are ignored. Use the raw values if needed.

get_account_storage_entry(address: Address, entry_key: str) → AccountStorageEntry[source]: Fetches a specific storage entry of an account.

get_block(block_hash: str | bytes) → BlockOnNetwork[source]: Fetches a block by hash.

get_definition_of_fungible_token(token_identifier: str) → FungibleTokenMetadata[source]: Fetches the definition of a fungible token.

get_definition_of_tokens_collection(collection_name: str) → TokensCollectionMetadata[source]: Fetches the definition of a tokens collection.

get_fungible_tokens_of_account(address: Address) → list[TokenAmountOnNetwork][source]: Fetches the balances of an account, for all fungible tokens held by the account. Pagination isn’t explicitly handled by a basic network provider, but can be achieved by using do_get_generic.

get_latest_block() → BlockOnNetwork[source]: Fetches the latest block of a shard.

get_network_config() → NetworkConfig[source]: Fetches the general configuration of the network.

get_network_status(shard: int = 4294967295) → NetworkStatus[source]: Fetches the current status of the network.

get_non_fungible_tokens_of_account(address: Address) → list[TokenAmountOnNetwork][source]: Fetches the balances of an account, for all non-fungible tokens held by the account. Pagination isn’t explicitly handled by a basic network provider, but can be achieved by using do_get_generic.

get_token_of_account(address: Address, token: Token) → TokenAmountOnNetwork[source]: Fetches the balance of an account, for a given token. Able to handle both fungible and non-fungible tokens (NFTs, SFTs, MetaESDTs).

get_transaction(transaction_hash: str | bytes) → TransactionOnNetwork[source]: Fetches a transaction that was previously broadcasted (maybe already processed by the network).

get_transactions(address: Address, url_parameters: dict[str, Any] | None = None) → list[TransactionOnNetwork][source]: Fetches the transactions of an account

query_contract(query: SmartContractQuery) → SmartContractQueryResponse[source]

send_transaction(transaction: Transaction) → bytes[source]: Broadcasts a transaction and returns its hash.

send_transactions(transactions: list[Transaction]) → tuple[int, list[bytes]][source]: Broadcasts multiple transactions and returns a tuple of (number of accepted transactions, list of transaction hashes). In the returned list, the order of transaction hashes corresponds to the order of transactions in the input list. If a transaction is not accepted, its hash is empty in the returned list.

simulate_transaction(transaction: Transaction, check_signature: bool = False) → TransactionOnNetwork[source]: Simulates a transaction.

class multiversx_sdk.AwaitingOptions(polling_interval_in_milliseconds: int = 6000, timeout_in_milliseconds: int = 90000, patience_in_milliseconds: int = 3000)[source]

Bases: object

patience_in_milliseconds: int = 3000

polling_interval_in_milliseconds: int = 6000

timeout_in_milliseconds: int = 90000

class multiversx_sdk.BlockCoordinates(nonce: str, hash: bytes, root_hash: bytes)[source]

Bases: object

hash: bytes

nonce: str

root_hash: bytes

class multiversx_sdk.BlockOnNetwork(raw: dict[str, Any], shard: int, nonce: int, hash: bytes, previous_hash: bytes, timestamp: int, round: int, epoch: int)[source]

Bases: object

epoch: int

hash: bytes

nonce: int

previous_hash: bytes

raw: dict[str, Any]

round: int

shard: int

timestamp: int

class multiversx_sdk.BurnOutcome(user_address: multiversx_sdk.core.address.Address, token_identifier: str, nonce: int, burnt_supply: int)[source]

Bases: object

burnt_supply: int

nonce: int

token_identifier: str

user_address: Address

class multiversx_sdk.BurnQuantityOutcome(token_identifier: str, nonce: int, burnt_quantity: int)[source]

Bases: object

burnt_quantity: int

nonce: int

token_identifier: str

class multiversx_sdk.CallActionData(to: Address, egld_amount: int, endpoint_name: str, arguments: list[bytes], opt_gas_limit: int | None = None)[source]: Bases: object

class multiversx_sdk.ChangeQuorum(quorum: int)[source]

Bases: Action

discriminant: int = 4

class multiversx_sdk.ChangeTokenToDynamicOutcome(token_identifier: str, token_name: str, ticker: str, token_type: str)[source]

Bases: object

ticker: str

token_identifier: str

token_name: str

token_type: str

class multiversx_sdk.CloseProposalOutcome(commit_hash: str, passed: bool)[source]

Bases: object

commit_hash: str

passed: bool

class multiversx_sdk.CodeMetadata(upgradeable: bool = True, readable: bool = True, payable: bool = False, payable_by_contract: bool = False)[source]

Bases: object

classmethod new_from_bytes(data: bytes) → CodeMetadata[source]

serialize() → bytes[source]

class multiversx_sdk.CreateNewDelegationContractOutcome(contract_address: multiversx_sdk.core.address.Address)[source]

Bases: object

contract_address: Address

class multiversx_sdk.DelegateVoteOutcome(proposal_nonce: int, vote: str, voter: multiversx_sdk.core.address.Address, user_stake: int, voting_power: int)[source]

Bases: object

proposal_nonce: int

user_stake: int

vote: str

voter: Address

voting_power: int

class multiversx_sdk.DelegatedVoteInfo(used_stake: int, used_power: int, total_stake: int, total_power: int)[source]

Bases: object

total_power: int

total_stake: int

used_power: int

used_stake: int

class multiversx_sdk.DelegationController(chain_id: str, network_provider: INetworkProvider, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseController

await_completed_claim_rewards(transaction_hash: str | bytes) → list[ClaimRewardsOutcome][source]

await_completed_create_new_delegation_contract(transaction_hash: str | bytes) → list[CreateNewDelegationContractOutcome][source]

await_completed_delegate(transaction_hash: str | bytes) → list[DelegateOutcome][source]

await_completed_redelegate_rewards(transaction_hash: str | bytes) → list[RedelegateRewardsOutcome][source]

await_completed_undelegate(transaction_hash: str | bytes) → list[UndelegateOutcome][source]

create_transaction_for_adding_nodes(sender: IAccount, nonce: int, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey], signed_messages: Sequence[bytes], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_changing_service_fee(sender: IAccount, nonce: int, delegation_contract: Address, service_fee: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_claiming_rewards(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_delegating(sender: IAccount, nonce: int, delegation_contract: Address, amount: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_modifying_delegation_cap(sender: IAccount, nonce: int, delegation_contract: Address, delegation_cap: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_new_delegation_contract(sender: IAccount, nonce: int, total_delegation_cap: int, service_fee: int, amount: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_redelegating_rewards(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_removing_nodes(sender: IAccount, nonce: int, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_automatic_activation(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_cap_check_on_redelegate_rewards(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_metadata(sender: IAccount, nonce: int, delegation_contract: Address, name: str, website: str, identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_staking_nodes(sender: IAccount, nonce: int, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unbonding_nodes(sender: IAccount, nonce: int, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_undelegating(sender: IAccount, nonce: int, delegation_contract: Address, amount: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unjailing_nodes(sender: IAccount, nonce: int, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey], amount: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unsetting_automatic_activation(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unsetting_cap_check_on_redelegate_rewards(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unstaking_nodes(sender: IAccount, nonce: int, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_whitelist_for_merge(sender: IAccount, nonce: int, delegation_contract: Address, validator_operator: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_withdrawing(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

parse_claim_rewards(transaction_on_network: TransactionOnNetwork) → list[ClaimRewardsOutcome][source]

parse_create_new_delegation_contract(transaction_on_network: TransactionOnNetwork) → list[CreateNewDelegationContractOutcome][source]

parse_delegate(transaction_on_network: TransactionOnNetwork) → list[DelegateOutcome][source]

parse_redelegate_rewards(transaction_on_network: TransactionOnNetwork) → list[RedelegateRewardsOutcome][source]

parse_undelegate(transaction_on_network: TransactionOnNetwork) → list[UndelegateOutcome][source]

class multiversx_sdk.DelegationTransactionsFactory(config: TransactionsFactoryConfig, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseFactory

create_transaction_for_adding_nodes(sender: Address, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey], signed_messages: Sequence[bytes]) → Transaction[source]

create_transaction_for_changing_service_fee(sender: Address, delegation_contract: Address, service_fee: int) → Transaction[source]

create_transaction_for_claiming_rewards(sender: Address, delegation_contract: Address) → Transaction[source]

create_transaction_for_delegating(sender: Address, delegation_contract: Address, amount: int) → Transaction[source]

create_transaction_for_modifying_delegation_cap(sender: Address, delegation_contract: Address, delegation_cap: int) → Transaction[source]

create_transaction_for_new_delegation_contract(sender: Address, total_delegation_cap: int, service_fee: int, amount: int) → Transaction[source]

create_transaction_for_redelegating_rewards(sender: Address, delegation_contract: Address) → Transaction[source]

create_transaction_for_removing_nodes(sender: Address, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_setting_automatic_activation(sender: Address, delegation_contract: Address) → Transaction[source]

create_transaction_for_setting_cap_check_on_redelegate_rewards(sender: Address, delegation_contract: Address) → Transaction[source]

create_transaction_for_setting_metadata(sender: Address, delegation_contract: Address, name: str, website: str, identifier: str) → Transaction[source]

create_transaction_for_staking_nodes(sender: Address, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_unbonding_nodes(sender: Address, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_undelegating(sender: Address, delegation_contract: Address, amount: int) → Transaction[source]

create_transaction_for_unjailing_nodes(sender: Address, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey], amount: int) → Transaction[source]

create_transaction_for_unsetting_automatic_activation(sender: Address, delegation_contract: Address) → Transaction[source]

create_transaction_for_unsetting_cap_check_on_redelegate_rewards(sender: Address, delegation_contract: Address) → Transaction[source]

create_transaction_for_unstaking_nodes(sender: Address, delegation_contract: Address, public_keys: Sequence[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_whitelist_for_merge(sender: Address, delegation_contract: Address, validator_operator: Address) → Transaction[source]

create_transaction_for_withdrawing(sender: Address, delegation_contract: Address) → Transaction[source]

class multiversx_sdk.DelegationTransactionsOutcomeParser[source]

Bases: object

parse_claim_rewards(transaction: TransactionOnNetwork) → list[ClaimRewardsOutcome][source]

parse_create_new_delegation_contract(transaction: TransactionOnNetwork) → list[CreateNewDelegationContractOutcome][source]

parse_delegate(transaction: TransactionOnNetwork) → list[DelegateOutcome][source]

parse_redelegate_rewards(transaction: TransactionOnNetwork) → list[RedelegateRewardsOutcome][source]

parse_undelegate(transaction: TransactionOnNetwork) → list[UndelegateOutcome][source]

class multiversx_sdk.DeployedSmartContract(address: multiversx_sdk.core.address.Address, owner_address: multiversx_sdk.core.address.Address, code_hash: bytes)[source]

Bases: object

address: Address

code_hash: bytes

owner_address: Address

class multiversx_sdk.DevnetEntrypoint(url: str | None = None, kind: str | None = None, with_gas_limit_estimator: bool | None = None, gas_limit_multiplier: float | None = None)[source]: Bases: NetworkEntrypoint

class multiversx_sdk.EsdtTokenPayment(token_identifier: str, token_nonce: int, amount: int)[source]: Bases: StructValue

class multiversx_sdk.EsdtTransferExecuteData(to: Address, tokens: list[EsdtTokenPayment], opt_gas_limit: int | None, endpoint_name: str, arguments: list[bytes])[source]: Bases: object

class multiversx_sdk.FreezeOutcome(user_address: multiversx_sdk.core.address.Address, token_identifier: str, nonce: int, balance: int)[source]

Bases: object

balance: int

nonce: int

token_identifier: str

user_address: Address

class multiversx_sdk.FungibleTokenMetadata(raw: dict[str, Any], identifier: str, name: str, ticker: str, owner: str, decimals: int)[source]

Bases: object

decimals: int

identifier: str

name: str

owner: str

raw: dict[str, Any]

ticker: str

class multiversx_sdk.GasLimitEstimator(network_provider: INetworkProvider, gas_multiplier: float | None = None)[source]

Bases: object

Initializes the gas limit estimator.

Args:: network_provider: The network provider for making API calls. gas_multiplier: Optional multiplier to adjust the estimated gas limit (default: None).

estimate_gas_limit(transaction: Transaction) → int[source]

Estimates the gas limit for the given transaction.

Args:: transaction: The transaction object to estimate gas for.
Returns:: int: The estimated gas limit, adjusted by the gas multiplier.

class multiversx_sdk.GenericResponse(data: Any)[source]

Bases: object

get(key: str, default: Any = None) → Any[source]

to_dictionary() → dict[str, Any][source]

class multiversx_sdk.GovernanceConfig(proposal_fee: int, lost_proposal_fee: int, min_quorum: float, min_pass_threshold: float, min_veto_threshold: float, last_proposal_nonce: int)[source]

Bases: object

last_proposal_nonce: int

lost_proposal_fee: int

min_pass_threshold: float

min_quorum: float

min_veto_threshold: float

proposal_fee: int

class multiversx_sdk.GovernanceController(chain_id: str, network_provider: INetworkProvider, address_hrp: str | None = None, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseController

await_completed_close_proposal(tx_hash: str | bytes) → list[CloseProposalOutcome][source]

await_completed_new_proposal(tx_hash: str | bytes) → list[NewProposalOutcome][source]

await_completed_vote(tx_hash: str | bytes) → list[VoteOutcome][source]

create_transaction_for_changing_config(sender: IAccount, nonce: int, proposal_fee: int, lost_proposal_fee: int, min_quorum: int, min_veto_threshold: int, min_pass_threshold: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_claiming_accumulated_fees(sender: IAccount, nonce: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_clearing_ended_proposals(sender: IAccount, nonce: int, proposers: list[Address], gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_closing_proposal(sender: IAccount, nonce: int, proposal_nonce: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_new_proposal(sender: IAccount, nonce: int, commit_hash: str, start_vote_epoch: int, end_vote_epoch: int, native_token_amount: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_voting(sender: IAccount, nonce: int, proposal_nonce: int, vote: VoteType, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

get_config() → GovernanceConfig[source]

get_delegated_vote_info(contract: Address, user: Address) → DelegatedVoteInfo[source]

get_proposal(proposal_nonce: int) → ProposalInfo[source]

get_voting_power(address: Address) → int[source]

parse_close_proposal(transaction_on_network: TransactionOnNetwork) → list[CloseProposalOutcome][source]

parse_new_proposal(transaction_on_network: TransactionOnNetwork) → list[NewProposalOutcome][source]

parse_vote(transaction_on_network: TransactionOnNetwork) → list[VoteOutcome][source]

class multiversx_sdk.GovernanceTransactionsFactory(config: TransactionsFactoryConfig, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseFactory

create_transaction_for_changing_config(sender: Address, proposal_fee: int, lost_proposal_fee: int, min_quorum: int, min_veto_threshold: int, min_pass_threshold: int) → Transaction[source]

create_transaction_for_claiming_accumulated_fees(sender: Address) → Transaction[source]

create_transaction_for_clearing_ended_proposals(sender: Address, proposers: list[Address]) → Transaction[source]

create_transaction_for_closing_proposal(sender: Address, proposal_nonce: int) → Transaction[source]

create_transaction_for_new_proposal(sender: Address, commit_hash: str, start_vote_epoch: int, end_vote_epoch: int, native_token_amount: int) → Transaction[source]

create_transaction_for_voting(sender: Address, proposal_nonce: int, vote: VoteType) → Transaction[source]

class multiversx_sdk.GovernanceTransactionsOutcomeParser(address_hrp: str | None = None)[source]

Bases: object

parse_close_proposal(transaction_on_network: TransactionOnNetwork) → list[CloseProposalOutcome][source]

parse_delegate_vote(transaction_on_network: TransactionOnNetwork) → list[DelegateVoteOutcome][source]

parse_new_proposal(transaction_on_network: TransactionOnNetwork) → list[NewProposalOutcome][source]

parse_vote(transaction_on_network: TransactionOnNetwork) → list[VoteOutcome][source]

class multiversx_sdk.IssueFungibleOutcome(token_identifier: str)[source]

Bases: object

token_identifier: str

class multiversx_sdk.IssueNonFungibleOutcome(token_identifier: str)[source]

Bases: object

token_identifier: str

class multiversx_sdk.IssueSemiFungibleOutcome(token_identifier: str)[source]

Bases: object

token_identifier: str

class multiversx_sdk.KeyPair(secret_key: UserSecretKey)[source]

Bases: object

static generate() → KeyPair[source]

get_public_key() → UserPublicKey[source]

get_secret_key() → UserSecretKey[source]

static new_from_bytes(data: bytes) → KeyPair[source]

sign(data: bytes) → bytes[source]: Signs using the secret key of the keypair.

verify(data: bytes, signature: bytes) → bool[source]: Verifies using the public key of the keypair.

class multiversx_sdk.LedgerAccount(address_index: int = 0)[source]

Bases: object

get_nonce_then_increment() → int[source]

set_address(address_index: int = 0)[source]: Sets the working address for the device. Also sets the address_index and address properties of the class.

sign_message(message: Message) → bytes[source]

sign_transaction(transaction: Transaction) → bytes[source]

class multiversx_sdk.LedgerApp[source]

Bases: object

close()[source]

get_address(address_index: int = 0) → str[source]

get_app_configuration() → LedgerAppConfiguration[source]

get_signature_from_apdus(apdus: list[Apdu]) → str[source]

get_version() → str[source]

set_address(address_index: int = 0)[source]

sign_message(message_bytes: bytes) → str[source]

sign_transaction(tx_bytes: bytes) → str[source]

class multiversx_sdk.LibraryConfig(default_address_hrp: str = 'erd')[source]

Bases: object

Global configuration of the library.

Generally speaking, this configuration should only be altered in exotic use cases. It can be seen as a collection of constants or, more precisely, variables that are rarely changed and used throughout the library.

Never alter the configuration within a library! Only alter the configuration, if needed, within a final application that uses this library.

default_address_hrp: str = 'erd'

class multiversx_sdk.LocalnetEntrypoint(url: str | None = None, kind: str | None = None, with_gas_limit_estimator: bool | None = None, gas_limit_multiplier: float | None = None)[source]: Bases: NetworkEntrypoint

class multiversx_sdk.MainnetEntrypoint(url: str | None = None, kind: str | None = None, with_gas_limit_estimator: bool | None = None, gas_limit_multiplier: float | None = None)[source]: Bases: NetworkEntrypoint

class multiversx_sdk.Message(data: bytes, signature: bytes = b'', address: Address | None = None, version: int = 1, signer: str = 'sdk-py')[source]: Bases: object

class multiversx_sdk.MessageComputer[source]

Bases: object

Also see:

https://github.com/multiversx/mx-sdk-js-core/blob/v11.2.0/src/signableMessage.ts
https://eips.ethereum.org/EIPS/eip-712 (in the past, it served as a basis for the implementation)

compute_bytes_for_signing(message: Message) → bytes[source]

compute_bytes_for_verifying(message: Message) → bytes[source]

pack_message(message: Message) → Dict[str, Any][source]

unpack_message(packed_message: Dict[str, Any]) → Message[source]

class multiversx_sdk.MetadataRecreateOutcome(token_identifier: str, nonce: int, metadata: bytes)[source]

Bases: object

metadata: bytes

nonce: int

token_identifier: str

class multiversx_sdk.MintOutcome(user_address: multiversx_sdk.core.address.Address, token_identifier: str, nonce: int, minted_supply: int)[source]

Bases: object

minted_supply: int

nonce: int

token_identifier: str

user_address: Address

class multiversx_sdk.Mnemonic(text: str)[source]

Bases: object

classmethod assert_text_is_valid(text: str) → None[source]

derive_key(address_index: int = 0) → UserSecretKey[source]

classmethod from_entropy(entropy: bytes) → Mnemonic[source]

classmethod generate() → Mnemonic[source]

get_entropy() → bytes[source]

get_text() → str[source]

get_words() → list[str][source]

classmethod is_text_valid(text: str) → bool[source]

class multiversx_sdk.ModifyCreatorOutcome(token_identifier: str, nonce: int)[source]

Bases: object

nonce: int

token_identifier: str

class multiversx_sdk.ModifyRoyaltiesOutcome(token_identifier: str, nonce: int, royalties: int)[source]

Bases: object

nonce: int

royalties: int

token_identifier: str

class multiversx_sdk.MultisigController(chain_id: str, network_provider: INetworkProvider, abi: Abi, address_hrp: str | None = None, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseController

await_completed_deploy(tx_hash: str | bytes) → SmartContractDeployOutcome[source]

await_completed_execute_propose_any(tx_hash: str | bytes) → int[source]

await_completed_perform_action(tx_hash: str | bytes) → Address | None[source]

create_transaction_for_deploy(sender: IAccount, nonce: int, bytecode: Path | bytes, quorum: int, board: list[Address], gas_limit: int | None = None, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_deposit(sender: IAccount, nonce: int, contract: Address, gas_limit: int | None = None, native_token_amount: int = 0, token_transfers: list[TokenTransfer] | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_discard_action(sender: IAccount, nonce: int, contract: Address, action_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_discard_batch(sender: IAccount, nonce: int, contract: Address, actions_ids: list[int], gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_execute(sender: IAccount, nonce: int, contract: Address, function: str, gas_limit: int | None = None, arguments: list[Any] = [], native_transfer_amount: int = 0, token_transfers: list[TokenTransfer] = [], gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_perform_action(sender: IAccount, nonce: int, contract: Address, action_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_perform_batch(sender: IAccount, nonce: int, contract: Address, batch_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_add_board_member(sender: IAccount, nonce: int, contract: Address, board_member: Address, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_add_proposer(sender: IAccount, nonce: int, contract: Address, proposer: Address, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_async_call(sender: IAccount, nonce: int, contract: Address, receiver: Address, gas_limit: int | None = None, native_token_amount: int = 0, token_transfers: list[TokenTransfer] | None = None, opt_gas_limit: int | None = None, abi: Abi | None = None, function: str | None = None, arguments: list[Any] | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_batch(sender: IAccount, nonce: int, contract: Address, actions: list[Action], gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_change_quorum(sender: IAccount, nonce: int, contract: Address, new_quorum: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_contract_deploy_from_source(sender: IAccount, nonce: int, contract: Address, contract_to_copy: Address, gas_limit: int | None = None, native_token_amount: int = 0, arguments: list[Any] | None = None, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True, abi: Abi | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_contract_upgrade_from_source(sender: IAccount, nonce: int, contract: Address, contract_to_upgrade: Address, contract_to_copy: Address, gas_limit: int | None = None, arguments: list[Any] | None = None, native_token_amount: int = 0, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True, abi: Abi | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_remove_user(sender: IAccount, nonce: int, contract: Address, user: Address, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_propose_transfer_execute(sender: IAccount, nonce: int, contract: Address, receiver: Address, native_token_amount: int, gas_limit: int | None = None, opt_gas_limit: int | None = None, abi: Abi | None = None, function: str | None = None, arguments: list[Any] | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]: Propose a transaction in which the contract will perform a transfer-execute call. Can send EGLD without calling anything. Can call smart contract endpoints directly. Doesn’t really work with builtin functions.

create_transaction_for_propose_transfer_execute_esdt(sender: IAccount, nonce: int, contract: Address, receiver: Address, token_transfers: list[TokenTransfer], gas_limit: int | None = None, opt_gas_limit: int | None = None, abi: Abi | None = None, function: str | None = None, arguments: list[Any] | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_sign_action(sender: IAccount, nonce: int, contract: Address, action_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_sign_and_perform(sender: IAccount, nonce: int, contract: Address, action_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_sign_batch(sender: IAccount, nonce: int, contract: Address, batch_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_sign_batch_and_perform(sender: IAccount, nonce: int, contract: Address, batch_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_unsign_action(sender: IAccount, nonce: int, contract: Address, action_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_unsign_batch(sender: IAccount, nonce: int, contract: Address, batch_id: int, gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_unsign_for_outdated_board_members(sender: IAccount, nonce: int, contract: Address, action_id: int, outdated_board_members: list[int], gas_limit: int | None = None, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

get_action_data(contract: Address, action_id: int) → Action[source]

get_action_group(contract: Address, group_id: int) → list[int][source]

get_action_last_index(contract: Address) → int[source]

get_action_signer_count(contract: Address, action_id: int) → int[source]

get_action_signers(contract: Address, action_id: int) → list[Address][source]

get_action_valid_signer_count(contract: Address, action_id: int) → int[source]

get_all_board_members(contract: Address) → list[Address][source]

get_all_proposers(contract: Address) → list[Address][source]

get_last_group_action_id(contract: Address) → int[source]

get_num_board_members(contract: Address) → int[source]

get_num_groups(contract: Address) → int[source]

get_num_proposers(contract: Address) → int[source]

get_pending_actions_full_info(contract: Address) → list[ActionFullInfo][source]

get_quorum(contract: Address) → int[source]

get_user_role(contract: Address, user: Address) → UserRole[source]

is_quorum_reached(contract: Address, action_id: int) → bool[source]

is_signed_by(contract: Address, user: Address, action_id: int) → bool[source]

parse_deploy(transaction_on_network: TransactionOnNetwork) → SmartContractDeployOutcome[source]

parse_perform_action(transaction_on_network: TransactionOnNetwork) → Address | None[source]

parse_propose_action(transaction_on_network: TransactionOnNetwork) → int[source]

query(contract: Address, function: str, arguments: list[Any], caller: Address | None = None, value: int | None = None) → list[Any][source]

class multiversx_sdk.MultisigTransactionsFactory(config: TransactionsFactoryConfig, abi: Abi, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseFactory

create_transaction_for_deploy(sender: Address, bytecode: Path | bytes, quorum: int, board: list[Address], gas_limit: int | None = None, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True) → Transaction[source]

create_transaction_for_deposit(sender: Address, contract: Address, gas_limit: int | None = None, native_token_amount: int | None = None, token_transfers: list[TokenTransfer] | None = None) → Transaction[source]

create_transaction_for_discard_action(sender: Address, contract: Address, action_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_discard_batch(sender: Address, contract: Address, action_ids: list[int], gas_limit: int | None = None) → Transaction[source]

create_transaction_for_execute(sender: Address, contract: Address, function: str, gas_limit: int | None = None, arguments: list[Any] = [], native_transfer_amount: int = 0, token_transfers: list[TokenTransfer] = []) → Transaction[source]

create_transaction_for_perform_action(sender: Address, contract: Address, action_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_perform_batch(sender: Address, contract: Address, batch_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_propose_add_board_member(sender: Address, contract: Address, board_member: Address, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_propose_add_proposer(sender: Address, contract: Address, proposer: Address, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_propose_async_call(sender: Address, contract: Address, receiver: Address, gas_limit: int | None = None, native_token_amount: int = 0, token_transfers: list[TokenTransfer] | None = None, opt_gas_limit: int | None = None, abi: Abi | None = None, function: str | None = None, arguments: list[Any] | None = None) → Transaction[source]

create_transaction_for_propose_batch(sender: Address, contract: Address, actions: list[Action], gas_limit: int | None = None) → Transaction[source]

create_transaction_for_propose_change_quorum(sender: Address, contract: Address, quorum: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_propose_contract_deploy_from_source(sender: Address, contract: Address, contract_to_copy: Address, gas_limit: int | None = None, native_token_amount: int = 0, arguments: list[Any] | None = None, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True, abi: Abi | None = None) → Transaction[source]

create_transaction_for_propose_contract_upgrade_from_source(sender: Address, contract: Address, contract_to_upgrade: Address, contract_to_copy: Address, gas_limit: int | None = None, arguments: list[Any] | None = None, native_token_amount: int = 0, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True, abi: Abi | None = None) → Transaction[source]

create_transaction_for_propose_remove_user(sender: Address, contract: Address, user: Address, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_propose_transfer_esdt_execute(sender: Address, contract: Address, receiver: Address, token_transfers: list[TokenTransfer], gas_limit: int | None = None, opt_gas_limit: int | None = None, abi: Abi | None = None, function: str | None = None, arguments: list[Any] | None = None) → Transaction[source]

create_transaction_for_propose_transfer_execute(sender: Address, contract: Address, receiver: Address, native_token_amount: int, gas_limit: int | None = None, opt_gas_limit: int | None = None, abi: Abi | None = None, function: str | None = None, arguments: list[Any] | None = None) → Transaction[source]

create_transaction_for_sign_action(sender: Address, contract: Address, action_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_sign_and_perform(sender: Address, contract: Address, action_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_sign_batch(sender: Address, contract: Address, batch_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_sign_batch_and_perform(sender: Address, contract: Address, batch_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_unsign_action(sender: Address, contract: Address, action_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_unsign_batch(sender: Address, contract: Address, batch_id: int, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_unsign_for_outdated_board_members(sender: Address, contract: Address, action_id: int, outdated_board_members: list[int], gas_limit: int | None = None) → Transaction[source]

class multiversx_sdk.MultisigTransactionsOutcomeParser(abi: Abi)[source]

Bases: object

parse_deploy(transaction_on_network: TransactionOnNetwork) → SmartContractDeployOutcome[source]

parse_perform_action(transaction_on_network: TransactionOnNetwork) → Address | None[source]

parse_propose_action(transaction_on_network: TransactionOnNetwork) → int[source]

class multiversx_sdk.NFTCreateOutcome(token_identifier: str, nonce: int, initial_quantity: int)[source]

Bases: object

initial_quantity: int

nonce: int

token_identifier: str

class multiversx_sdk.NativeAuthClient(config: NativeAuthClientConfig | None = None)[source]

Bases: object

get_current_block_hash() → str[source]

get_token(address: Address, token: str, signature: str) → str[source]

get_token_for_signing(address: Address, init_token: str) → bytes[source]

initialize(extra_info: dict[Any, Any] | None = None) → str[source]

class multiversx_sdk.NativeAuthClientConfig(origin: str = '', api_url: str = 'https://api.multiversx.com', expiry_seconds: int = 7200, block_hash_shard: int | None = None, gateway_url: str | None = None, extra_request_headers: dict[str, str] | None = None)[source]: Bases: object

class multiversx_sdk.NativeAuthServer(config: NativeAuthServerConfig, cache: NativeAuthCacheInterface | None = None)[source]

Bases: object

decode(access_token: str) → NativeAuthDecoded[source]

is_valid(access_token: str) → bool[source]

validate(access_token: str) → NativeAuthValidateResult[source]

class multiversx_sdk.NativeAuthServerConfig(api_url: str = 'https://api.multiversx.com', accepted_origins: list[str] = <factory>, validate_impersonate_url: str | None = None, validate_impersonate_callback: ~typing.Callable[[str, str], bool] | None = None, is_origin_accepted: ~typing.Callable[[str], bool] | None = None, max_expiry_seconds: int = 86400, skip_legacy_validation: bool = False, extra_request_headers: dict[str, str] | None = None, verify_signature: ~typing.Callable[[str, str, bytes], bool] | None = None)[source]

Bases: object

Configuration for Native Authentication.

Attributes:: api_url: Optional API URL (default: https://api.multiversx.com). accepted_origins: Mandatory list of accepted origins (must have at least one value). validate_impersonate_url: Optional endpoint for validating impersonation. validate_impersonate_callback: Optional callback function to validate impersonation. is_origin_accepted: Optional callback to validate an origin dynamically. max_expiry_seconds: Maximum allowed TTL (default: 86400 seconds, one day). skip_legacy_validation: Determines whether legacy signature validation should be skipped. extra_request_headers: Optional extra request headers. verify_signature: Optional function to verify signatures.

accepted_origins: list[str]

api_url: str = 'https://api.multiversx.com'

extra_request_headers: dict[str, str] | None = None

is_origin_accepted: Callable[[str], bool] | None = None

max_expiry_seconds: int = 86400

skip_legacy_validation: bool = False

validate_impersonate_callback: Callable[[str, str], bool] | None = None

validate_impersonate_url: str | None = None

verify_signature: Callable[[str, str, bytes], bool] | None = None

class multiversx_sdk.NetworkConfig(raw: dict[str, Any], chain_id: str, gas_per_data_byte: int, gas_price_modifier: float, min_gas_limit: int, min_gas_price: int, extra_gas_limit_for_guarded_transactions: int, num_shards: int, round_duration: int, num_rounds_per_epoch: int, genesis_timestamp: int)[source]

Bases: object

chain_id: str

extra_gas_limit_for_guarded_transactions: int

gas_per_data_byte: int

gas_price_modifier: float

genesis_timestamp: int

min_gas_limit: int

min_gas_price: int

num_rounds_per_epoch: int

num_shards: int

raw: dict[str, Any]

round_duration: int

class multiversx_sdk.NetworkEntrypoint(network_provider_url: str | None = None, network_provider_kind: str | None = None, chain_id: str | None = None, network_provider: INetworkProvider | None = None, with_gas_limit_estimator: bool | None = None, gas_limit_multiplier: float | None = None)[source]

Bases: object

await_transaction_completed(tx_hash: str | bytes) → TransactionOnNetwork[source]

create_account() → Account[source]: Generates a new secret key and instantiates an account.

create_account_controller() → AccountController[source]

create_account_transactions_factory() → AccountTransactionsFactory[source]

create_delegation_controller() → DelegationController[source]

create_delegation_transactions_factory() → DelegationTransactionsFactory[source]

create_gas_limit_estimator() → GasLimitEstimator[source]

create_governance_controller(address_hrp: str | None = None) → GovernanceController[source]

create_governance_transactions_factory() → GovernanceTransactionsFactory[source]

create_multisig_controller(abi: Abi, address_hrp: str | None = None) → MultisigController[source]

create_multisig_transactions_factory(abi: Abi) → MultisigTransactionsFactory[source]

create_network_provider() → INetworkProvider[source]

create_smart_contract_controller(abi: Abi | None = None) → SmartContractController[source]

create_smart_contract_transactions_factory(abi: Abi | None = None) → SmartContractTransactionsFactory[source]

create_token_management_controller() → TokenManagementController[source]

create_token_management_transactions_factory() → TokenManagementTransactionsFactory[source]

create_transfers_controller() → TransfersController[source]

create_transfers_transactions_factory() → TransferTransactionsFactory[source]

get_airdrop(address: Address) → None[source]: Get xEGLD tokens on Devnet or Testnet.

get_transaction(tx_hash: str | bytes) → TransactionOnNetwork[source]

classmethod new_from_network_provider(network_provider: INetworkProvider, chain_id: str | None = None) → NetworkEntrypoint[source]

recall_account_nonce(address: Address) → int[source]

send_transaction(transaction: Transaction) → bytes[source]

send_transactions(transactions: list[Transaction]) → tuple[int, list[bytes]][source]

Sends multiple transactions.

Args:: transactions (list[Transaction]): An iterable containing multiple transactions (e.g. a list of transactions).
Returns:: tuple (int, list[bytes]): The integer indicates the total number of transactions sent, while the list contains the transactions hashes. If a transaction is not sent, the hash is empty.

verify_message_signature(message: Message) → bool[source]

verify_transaction_signature(transaction: Transaction) → bool[source]

class multiversx_sdk.NetworkProviderConfig(client_name: str | None = None, requests_options: dict[str, Any] | None = None, requests_retry_options: RequestsRetryOptions | None = None)[source]: Bases: object

exception multiversx_sdk.NetworkProviderError(url: str, data: Any)[source]: Bases: Exception

class multiversx_sdk.NetworkStatus(raw: dict[str, Any], block_timestamp: int, block_nonce: int, highest_final_block_nonce: int, current_round: int, current_epoch: int)[source]

Bases: object

block_nonce: int

block_timestamp: int

current_epoch: int

current_round: int

highest_final_block_nonce: int

raw: dict[str, Any]

class multiversx_sdk.NewProposalOutcome(proposal_nonce: int, commit_hash: str, start_vote_epoch: int, end_vote_epoch: int)[source]

Bases: object

commit_hash: str

end_vote_epoch: int

proposal_nonce: int

start_vote_epoch: int

class multiversx_sdk.ParsedSmartContractCallOutcome(values: list[Any], return_code: str, return_message: str)[source]

Bases: object

return_code: str

return_message: str

values: list[Any]

class multiversx_sdk.PauseOutcome(token_identifier: str)[source]

Bases: object

token_identifier: str

class multiversx_sdk.ProposalInfo(cost: int, commit_hash: str, nonce: int, issuer: multiversx_sdk.core.address.Address, start_vote_epoch: int, end_vote_epoch: int, quorum_stake: int, num_yes_votes: int, num_no_votes: int, num_veto_votes: int, num_abstain_votes: int, is_closed: bool, is_passed: bool)[source]

Bases: object

commit_hash: str

cost: int

end_vote_epoch: int

is_closed: bool

is_passed: bool

issuer: Address

nonce: int

num_abstain_votes: int

num_no_votes: int

num_veto_votes: int

num_yes_votes: int

quorum_stake: int

start_vote_epoch: int

class multiversx_sdk.ProxyNetworkProvider(url: str, address_hrp: str | None = None, config: NetworkProviderConfig | None = None)[source]

Bases: INetworkProvider

await_account_on_condition(address: Address, condition: Callable[[AccountOnNetwork], bool], options: AwaitingOptions | None = None) → AccountOnNetwork[source]: Waits until an account satisfies a given condition.

await_transaction_completed(transaction_hash: bytes | str, options: AwaitingOptions | None = None) → TransactionOnNetwork[source]: Waits until the transaction is completely processed.

await_transaction_on_condition(transaction_hash: str | bytes, condition: Callable[[TransactionOnNetwork], bool], options: AwaitingOptions | None = None) → TransactionOnNetwork[source]: Waits until a transaction satisfies a given condition.

do_get_generic(url: str, url_parameters: dict[str, Any] | None = None) → GenericResponse[source]: Does a generic GET request against the network (handles API enveloping).

do_post_generic(url: str, data: Any, url_parameters: dict[str, Any] | None = None) → GenericResponse[source]: Does a generic GET request against the network (handles API enveloping).

estimate_transaction_cost(transaction: Transaction) → TransactionCostResponse[source]: Estimates the cost of a transaction.

get_account(address: Address) → AccountOnNetwork[source]: Fetches account information for a given address.

get_account_storage(address: Address) → AccountStorage[source]: Fetches the storage (key-value pairs) of an account. When decoding the keys, the errors are ignored. Use the raw values if needed.

get_account_storage_entry(address: Address, entry_key: str) → AccountStorageEntry[source]: Fetches a specific storage entry of an account.

get_block(shard: int, block_hash: str | bytes | None = None, block_nonce: int | None = None) → BlockOnNetwork[source]: Fetches a block by nonce or by hash.

get_definition_of_fungible_token(token_identifier: str) → FungibleTokenMetadata[source]: Fetches the definition of a fungible token.

get_definition_of_tokens_collection(collection_name: str) → TokensCollectionMetadata[source]: Fetches the definition of a tokens collection.

get_fungible_tokens_of_account(address: Address) → list[TokenAmountOnNetwork][source]: Fetches the balances of an account, for all fungible tokens held by the account. Pagination isn’t explicitly handled by a basic network provider, but can be achieved by using do_get_generic.

get_latest_block(shard: int = 4294967295) → BlockOnNetwork[source]: Fetches the latest block of a shard.

get_network_config() → NetworkConfig[source]: Fetches the general configuration of the network.

get_network_status(shard: int = 4294967295) → NetworkStatus[source]: Fetches the current status of the network.

get_non_fungible_tokens_of_account(address: Address) → list[TokenAmountOnNetwork][source]: Fetches the balances of an account, for all non-fungible tokens held by the account. Pagination isn’t explicitly handled by a basic network provider, but can be achieved by using do_get_generic.

get_token_of_account(address: Address, token: Token) → TokenAmountOnNetwork[source]: Fetches the balance of an account, for a given token. Able to handle both fungible and non-fungible tokens (NFTs, SFTs, MetaESDTs).

get_transaction(transaction_hash: bytes | str) → TransactionOnNetwork[source]: Fetches a transaction that was previously broadcasted (maybe already processed by the network).

get_transaction_status(transaction_hash: str | bytes) → TransactionStatus[source]: Fetches the status of a transaction.

query_contract(query: SmartContractQuery) → SmartContractQueryResponse[source]: Queries a smart contract.

send_transaction(transaction: Transaction) → bytes[source]: Broadcasts a transaction and returns its hash.

send_transactions(transactions: list[Transaction]) → tuple[int, list[bytes]][source]: Broadcasts multiple transactions and returns a tuple of (number of accepted transactions, list of transaction hashes). In the returned list, the order of transaction hashes corresponds to the order of transactions in the input list. If a transaction is not accepted, its hash is empty in the returned list.

simulate_transaction(transaction: Transaction, check_signature: bool = False) → TransactionOnNetwork[source]: Simulates a transaction.

class multiversx_sdk.RegisterAndSetAllRolesOutcome(token_identifier: str, roles: list[str])[source]

Bases: object

roles: list[str]

token_identifier: str

class multiversx_sdk.RegisterDynamicOutcome(token_identifier: str, token_name: str, ticker: str, token_type: str, num_of_decimals: int)[source]

Bases: object

num_of_decimals: int

ticker: str

token_identifier: str

token_name: str

token_type: str

class multiversx_sdk.RegisterMetaEsdtOutcome(token_identifier: str)[source]

Bases: object

token_identifier: str

class multiversx_sdk.RemoveUser(address: Address)[source]

Bases: Action

discriminant: int = 3

class multiversx_sdk.RequestsRetryOptions(retries: int = 3, backoff_factor: float = 1, status_forcelist: list[int] = <factory>)[source]

Bases: object

backoff_factor: float = 1

retries: int = 3

status_forcelist: list[int]

class multiversx_sdk.SCDeployFromSource(amount: int, source: Address, code_metadata: bytes, arguments: list[bytes])[source]

Bases: Action

discriminant: int = 8

class multiversx_sdk.SCUpgradeFromSource(sc_address: Address, amount: int, source: Address, code_metadata: bytes, arguments: list[bytes])[source]

Bases: Action

discriminant: int = 9

class multiversx_sdk.SendAsyncCall(data: CallActionData)[source]

Bases: Action

discriminant: int = 7

class multiversx_sdk.SendTransferExecuteEgld(data: CallActionData)[source]

Bases: Action

discriminant: int = 5

class multiversx_sdk.SendTransferExecuteEsdt(data: EsdtTransferExecuteData)[source]

Bases: Action

discriminant: int = 6

class multiversx_sdk.SetNewUrisOutcome(token_identifier: str, nonce: int, uris: list[str])[source]

Bases: object

nonce: int

token_identifier: str

uris: list[str]

class multiversx_sdk.SetSpecialRoleOutcome(user_address: multiversx_sdk.core.address.Address, token_identifier: str, roles: list[str])[source]

Bases: object

roles: list[str]

token_identifier: str

user_address: Address

class multiversx_sdk.SmartContractController(chain_id: str, network_provider: INetworkProvider, abi: Abi | None = None, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseController

await_completed_deploy(transaction_hash: str | bytes) → SmartContractDeployOutcome[source]

await_completed_execute(transaction_hash: str | bytes) → ParsedSmartContractCallOutcome[source]

create_query(contract: Address, function: str, arguments: list[Any], caller: Address | None = None, value: int | None = None) → SmartContractQuery[source]

create_transaction_for_deploy(sender: IAccount, nonce: int, bytecode: Path | bytes, gas_limit: int | None = None, arguments: Sequence[Any] = [], native_transfer_amount: int = 0, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_execute(sender: IAccount, nonce: int, contract: Address, function: str, gas_limit: int | None = None, arguments: Sequence[Any] = [], native_transfer_amount: int = 0, token_transfers: list[TokenTransfer] = [], gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

create_transaction_for_upgrade(sender: IAccount, nonce: int, contract: Address, bytecode: Path | bytes, gas_limit: int | None = None, arguments: Sequence[Any] = [], native_transfer_amount: int = 0, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True, gas_price: int | None = None, guardian: Address | None = None, relayer: Address | None = None) → Transaction[source]

parse_deploy(transaction_on_network: TransactionOnNetwork) → SmartContractDeployOutcome[source]

parse_execute(transaction_on_network: TransactionOnNetwork, function: str | None = None) → ParsedSmartContractCallOutcome[source]

parse_query_response(response: SmartContractQueryResponse) → list[Any][source]

query(contract: Address, function: str, arguments: list[Any], caller: Address | None = None, value: int | None = None) → list[Any][source]: It calls create_query(), run_query() and parse_query_response() in one go.

run_query(query: SmartContractQuery) → SmartContractQueryResponse[source]

class multiversx_sdk.SmartContractDeployOutcome(return_code: str, return_message: str, contracts: list[multiversx_sdk.smart_contracts.smart_contract_transactions_outcome_parser_types.DeployedSmartContract])[source]

Bases: object

contracts: list[DeployedSmartContract]

return_code: str

return_message: str

class multiversx_sdk.SmartContractQuery(contract: Address, function: str, arguments: list[bytes], caller: Address | None = None, value: int | None = None)[source]: Bases: object

class multiversx_sdk.SmartContractQueryResponse(function: str, return_code: str, return_message: str, return_data_parts: list[bytes])[source]: Bases: object

class multiversx_sdk.SmartContractResult(raw: dict[str, Any], sender: multiversx_sdk.core.address.Address, receiver: multiversx_sdk.core.address.Address, data: bytes, logs: multiversx_sdk.core.transaction_on_network.TransactionLogs)[source]

Bases: object

data: bytes

logs: TransactionLogs

raw: dict[str, Any]

receiver: Address

sender: Address

class multiversx_sdk.SmartContractTransactionsFactory(config: TransactionsFactoryConfig, abi: Abi | None = None, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseFactory

create_transaction_for_changing_owner_address(sender: Address, contract: Address, new_owner: Address, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_claiming_developer_rewards(sender: Address, contract: Address, gas_limit: int | None = None) → Transaction[source]

create_transaction_for_deploy(sender: Address, bytecode: Path | bytes, gas_limit: int | None = None, arguments: Sequence[Any] = [], native_transfer_amount: int = 0, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True) → Transaction[source]

create_transaction_for_execute(sender: Address, contract: Address, function: str, gas_limit: int | None = None, arguments: Sequence[Any] = [], native_transfer_amount: int = 0, token_transfers: list[TokenTransfer] = []) → Transaction[source]

create_transaction_for_upgrade(sender: Address, contract: Address, bytecode: Path | bytes, gas_limit: int | None = None, arguments: Sequence[Any] = [], native_transfer_amount: int = 0, is_upgradeable: bool = True, is_readable: bool = True, is_payable: bool = False, is_payable_by_sc: bool = True) → Transaction[source]

class multiversx_sdk.SmartContractTransactionsOutcomeParser(abi: Abi | None = None)[source]

Bases: object

parse_deploy(transaction: TransactionOnNetwork) → SmartContractDeployOutcome[source]

parse_execute(transaction: TransactionOnNetwork, function: str | None = None) → ParsedSmartContractCallOutcome[source]

class multiversx_sdk.TestnetEntrypoint(url: str | None = None, kind: str | None = None, with_gas_limit_estimator: bool | None = None, gas_limit_multiplier: float | None = None)[source]: Bases: NetworkEntrypoint

class multiversx_sdk.Token(identifier: str, nonce: int = 0)[source]: Bases: object

class multiversx_sdk.TokenAmountOnNetwork(raw: dict[str, Any], token: multiversx_sdk.core.tokens.Token, amount: int, attributes: bytes, block_coordinates: multiversx_sdk.network_providers.resources.BlockCoordinates | None = None)[source]

Bases: object

amount: int

attributes: bytes

block_coordinates: BlockCoordinates | None = None

raw: dict[str, Any]

token: Token

class multiversx_sdk.TokenComputer[source]

Bases: object

compute_extended_identifier(token: Token) → str[source]

compute_extended_identifier_from_identifier_and_nonce(identifier: str, nonce: int) → str[source]

compute_extended_identifier_from_parts(parts: TokenIdentifierParts) → str[source]

extract_identifier_from_extended_identifier(identifier: str) → str[source]

extract_nonce_from_extended_identifier(identifier: str) → int[source]

extract_ticker_from_identifier(identifier: str) → str[source]

is_fungible(token: Token) → bool[source]

parse_extended_identifier_parts(identifier: str) → TokenIdentifierParts[source]

class multiversx_sdk.TokenIdentifierParts(ticker: str, random_sequence: str, nonce: int, prefix: str | None = None)[source]: Bases: object

class multiversx_sdk.TokenManagementController(chain_id: str, network_provider: INetworkProvider, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseController

await_completed_add_quantity(transaction_hash: str | bytes) → list[AddQuantityOutcome][source]

await_completed_burn_quantity(transaction_hash: str | bytes) → list[BurnQuantityOutcome][source]

await_completed_change_token_to_dynamic(transaction_hash: str | bytes) → list[ChangeTokenToDynamicOutcome][source]

await_completed_create_nft(transaction_hash: str | bytes) → list[NFTCreateOutcome][source]

await_completed_freeze(transaction_hash: str | bytes) → list[FreezeOutcome][source]

await_completed_issue_fungible(transaction_hash: str | bytes) → list[IssueFungibleOutcome][source]

await_completed_issue_non_fungible(transaction_hash: str | bytes) → list[IssueNonFungibleOutcome][source]

await_completed_issue_semi_fungible(transaction_hash: str | bytes) → list[IssueSemiFungibleOutcome][source]

await_completed_local_burn(transaction_hash: str | bytes) → list[BurnOutcome][source]

await_completed_local_mint(transaction_hash: str | bytes) → list[MintOutcome][source]

await_completed_metadata_recreate(transaction_hash: str | bytes) → list[MetadataRecreateOutcome][source]

await_completed_modify_creator(transaction_hash: str | bytes) → list[ModifyCreatorOutcome][source]

await_completed_modify_royalties(transaction_hash: str | bytes) → list[ModifyRoyaltiesOutcome][source]

await_completed_pause(transaction_hash: str | bytes) → list[PauseOutcome][source]

await_completed_register_and_set_all_roles(transaction_hash: str | bytes) → list[RegisterAndSetAllRolesOutcome][source]

await_completed_register_dynamic_token(transaction_hash: str | bytes) → list[RegisterDynamicOutcome][source]

await_completed_register_dynamic_token_and_setting_roles(transaction_hash: str | bytes) → list[RegisterDynamicOutcome][source]

await_completed_register_meta_esdt(transaction_hash: str | bytes) → list[RegisterMetaEsdtOutcome][source]

await_completed_set_burn_role_globally(transaction_hash: str | bytes)[source]

await_completed_set_new_uris(transaction_hash: str | bytes) → list[SetNewUrisOutcome][source]

await_completed_set_special_role_on_fungible_token(transaction_hash: str | bytes) → list[SetSpecialRoleOutcome][source]

await_completed_set_special_role_on_meta_esdt(transaction_hash: str | bytes) → list[SetSpecialRoleOutcome][source]

await_completed_set_special_role_on_non_fungible_token(transaction_hash: str | bytes) → list[SetSpecialRoleOutcome][source]

await_completed_set_special_role_on_semi_fungible_token(transaction_hash: str | bytes) → list[SetSpecialRoleOutcome][source]

await_completed_unfreeze(transaction_hash: str | bytes) → list[UnFreezeOutcome][source]

await_completed_unpause(transaction_hash: str | bytes) → list[UnPauseOutcome][source]

await_completed_unset_burn_role_globally(transaction_hash: str | bytes)[source]

await_completed_update_attributes(transaction_hash: str | bytes) → list[UpdateAttributesOutcome][source]

await_completed_update_metadata(transaction_hash: str | bytes) → list[UpdateMetadataOutcome][source]

await_completed_update_token_id(transaction_hash: str | bytes) → TransactionOnNetwork[source]

await_completed_wipe(transaction_hash: str | bytes) → list[WipeOutcome][source]

create_transaction_for_adding_quantity(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, quantity_to_add: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_adding_uris(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, uris: list[str], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_burning_quantity(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, quantity_to_burn: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_changing_sft_to_meta_esdt(sender: IAccount, nonce: int, collection: str, num_decimals: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_changing_token_to_dynamic(sender: IAccount, nonce: int, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]: The following token types cannot be changed to dynamic: FungibleESDT, NonFungibleESDT, NonFungibleESDTv2

create_transaction_for_creating_nft(sender: IAccount, nonce: int, token_identifier: str, initial_quantity: int, name: str, royalties: int, hash: str, attributes: bytes, uris: list[str], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_freezing(sender: IAccount, nonce: int, user: Address, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_freezing_single_nft(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, user: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_issuing_fungible(sender: IAccount, nonce: int, token_name: str, token_ticker: str, initial_supply: int, num_decimals: int, can_freeze: bool, can_wipe: bool, can_pause: bool, can_change_owner: bool, can_upgrade: bool, can_add_special_roles: bool, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_issuing_non_fungible(sender: IAccount, nonce: int, token_name: str, token_ticker: str, can_freeze: bool, can_wipe: bool, can_pause: bool, can_transfer_nft_create_role: bool, can_change_owner: bool, can_upgrade: bool, can_add_special_roles: bool, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_issuing_semi_fungible(sender: IAccount, nonce: int, token_name: str, token_ticker: str, can_freeze: bool, can_wipe: bool, can_pause: bool, can_transfer_nft_create_role: bool, can_change_owner: bool, can_upgrade: bool, can_add_special_roles: bool, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_local_burning(sender: IAccount, nonce: int, token_identifier: str, supply_to_burn: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_local_minting(sender: IAccount, nonce: int, token_identifier: str, supply_to_mint: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_modifying_creator(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_modifying_royalties(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, new_royalties: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_nft_metadata_recreate(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, new_token_name: str, new_royalties: int, new_hash: str, new_attributes: bytes, new_uris: list[str], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_pausing(sender: IAccount, nonce: int, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_registering_and_setting_roles(sender: IAccount, nonce: int, token_name: str, token_ticker: str, token_type: TokenType, num_decimals: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_registering_dynamic_and_setting_roles(sender: IAccount, nonce: int, token_name: str, token_ticker: str, token_type: TokenType, denominator: int | None = None, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_registering_dynamic_token(sender: IAccount, nonce: int, token_name: str, token_ticker: str, token_type: TokenType, denominator: int | None = None, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_registering_meta_esdt(sender: IAccount, nonce: int, token_name: str, token_ticker: str, num_decimals: int, can_freeze: bool, can_wipe: bool, can_pause: bool, can_transfer_nft_create_role: bool, can_change_owner: bool, can_upgrade: bool, can_add_special_roles: bool, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_burn_role_globally(sender: IAccount, nonce: int, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_new_uris(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, new_uris: list[str], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_special_role_on_fungible_token(sender: IAccount, nonce: int, user: Address, token_identifier: str, add_role_local_mint: bool = False, add_role_local_burn: bool = False, add_role_esdt_transfer_role: bool = False, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_special_role_on_meta_esdt(sender: IAccount, nonce: int, user: Address, token_identifier: str, add_role_nft_create: bool = False, add_role_nft_burn: bool = False, add_role_nft_add_quantity: bool = False, add_role_esdt_transfer_role: bool = False, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_special_role_on_non_fungible_token(sender: IAccount, nonce: int, user: Address, token_identifier: str, add_role_nft_create: bool = False, add_role_nft_burn: bool = False, add_role_nft_update_attributes: bool = False, add_role_nft_add_uri: bool = False, add_role_esdt_transfer_role: bool = False, add_role_nft_update: bool = False, add_role_esdt_modify_royalties: bool = False, add_role_esdt_set_new_uri: bool = False, add_role_esdt_modify_creator: bool = False, add_role_nft_recreate: bool = False, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_setting_special_role_on_semi_fungible_token(sender: IAccount, nonce: int, user: Address, token_identifier: str, add_role_nft_create: bool = False, add_role_nft_burn: bool = False, add_role_nft_add_quantity: bool = False, add_role_esdt_transfer_role: bool = False, add_role_nft_update: bool = False, add_role_esdt_modify_royalties: bool = False, add_role_esdt_set_new_uri: bool = False, add_role_esdt_modify_creator: bool = False, add_role_nft_recreate: bool = False, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_stopping_nft_creation(sender: IAccount, nonce: int, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_transferring_nft_create_role(sender: IAccount, nonce: int, token_identifier: str, user: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_transferring_ownership(sender: IAccount, nonce: int, token_identifier: str, new_owner: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unfreezing(sender: IAccount, nonce: int, user: Address, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unfreezing_single_nft(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, user: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unpausing(sender: IAccount, nonce: int, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unsetting_burn_role_globally(sender: IAccount, nonce: int, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unsetting_special_role_on_fungible_token(sender: IAccount, nonce: int, user: Address, token_identifier: str, remove_role_local_mint: bool = False, remove_role_local_burn: bool = False, remove_role_esdt_transfer_role: bool = False, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unsetting_special_role_on_meta_esdt(sender: IAccount, user: Address, nonce: int, token_identifier: str, remove_role_nft_burn: bool = False, remove_role_nft_add_quantity: bool = False, remove_role_esdt_transfer_role: bool = False, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unsetting_special_role_on_non_fungible_token(sender: IAccount, nonce: int, user: Address, token_identifier: str, remove_role_nft_burn: bool = False, remove_role_nft_update_attributes: bool = False, remove_role_nft_remove_uri: bool = False, remove_role_esdt_transfer_role: bool = False, remove_role_nft_update: bool = False, remove_role_esdt_modify_royalties: bool = False, remove_role_esdt_set_new_uri: bool = False, remove_role_esdt_modify_creator: bool = False, remove_role_nft_recreate: bool = False, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unsetting_special_role_on_semi_fungible_token(sender: IAccount, user: Address, nonce: int, token_identifier: str, remove_role_nft_burn: bool = False, remove_role_nft_add_quantity: bool = False, remove_role_esdt_transfer_role: bool = False, remove_role_nft_update: bool = False, remove_role_esdt_modify_royalties: bool = False, remove_role_esdt_set_new_uri: bool = False, remove_role_esdt_modify_creator: bool = False, remove_role_nft_recreate: bool = False, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_updating_attributes(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, attributes: bytes, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_updating_metadata(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, new_token_name: str, new_royalties: int, new_hash: str, new_attributes: bytes, new_uris: list[str], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_updating_token_id(sender: IAccount, nonce: int, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_wiping(sender: IAccount, nonce: int, user: Address, token_identifier: str, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_wiping_single_nft(sender: IAccount, nonce: int, token_identifier: str, token_nonce: int, user: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

parse_add_quantity(transaction_on_network: TransactionOnNetwork) → list[AddQuantityOutcome][source]

parse_burn_quantity(transaction_on_network: TransactionOnNetwork) → list[BurnQuantityOutcome][source]

parse_change_token_to_dynamic(transaction_on_network: TransactionOnNetwork) → list[ChangeTokenToDynamicOutcome][source]

parse_create_nft(transaction_on_network: TransactionOnNetwork) → list[NFTCreateOutcome][source]

parse_freeze(transaction_on_network: TransactionOnNetwork) → list[FreezeOutcome][source]

parse_issue_fungible(transaction_on_network: TransactionOnNetwork) → list[IssueFungibleOutcome][source]

parse_issue_non_fungible(transaction_on_network: TransactionOnNetwork) → list[IssueNonFungibleOutcome][source]

parse_issue_semi_fungible(transaction_on_network: TransactionOnNetwork) → list[IssueSemiFungibleOutcome][source]

parse_local_burn(transaction_on_network: TransactionOnNetwork) → list[BurnOutcome][source]

parse_local_mint(transaction_on_network: TransactionOnNetwork) → list[MintOutcome][source]

parse_metadata_recreate(transaction_on_network: TransactionOnNetwork) → list[MetadataRecreateOutcome][source]

parse_modify_creator(transaction_on_network: TransactionOnNetwork) → list[ModifyCreatorOutcome][source]

parse_modify_royalties(transaction_on_network: TransactionOnNetwork) → list[ModifyRoyaltiesOutcome][source]

parse_pause(transaction_on_network: TransactionOnNetwork) → list[PauseOutcome][source]

parse_register_and_set_all_roles(transaction_on_network: TransactionOnNetwork) → list[RegisterAndSetAllRolesOutcome][source]

parse_register_dynamic_token(transaction_on_network: TransactionOnNetwork) → list[RegisterDynamicOutcome][source]

parse_register_dynamic_token_and_setting_roles(transaction_on_network: TransactionOnNetwork) → list[RegisterDynamicOutcome][source]

parse_register_meta_esdt(transaction_on_network: TransactionOnNetwork) → list[RegisterMetaEsdtOutcome][source]

parse_set_burn_role_globally(transaction_on_network: TransactionOnNetwork)[source]

parse_set_new_uris(transaction_on_network: TransactionOnNetwork) → list[SetNewUrisOutcome][source]

parse_set_special_role_on_fungible_token(transaction_on_network: TransactionOnNetwork) → list[SetSpecialRoleOutcome][source]

parse_set_special_role_on_meta_esdt(transaction_on_network: TransactionOnNetwork) → list[SetSpecialRoleOutcome][source]

parse_set_special_role_on_non_fungible_token(transaction_on_network: TransactionOnNetwork) → list[SetSpecialRoleOutcome][source]

parse_set_special_role_on_semi_fungible_token(transaction_on_network: TransactionOnNetwork) → list[SetSpecialRoleOutcome][source]

parse_unfreeze(transaction_on_network: TransactionOnNetwork) → list[UnFreezeOutcome][source]

parse_unpause(transaction_on_network: TransactionOnNetwork) → list[UnPauseOutcome][source]

parse_unset_burn_role_globally(transaction_on_network: TransactionOnNetwork)[source]

parse_update_attributes(transaction_on_network: TransactionOnNetwork) → list[UpdateAttributesOutcome][source]

parse_update_metadata(transaction_on_network: TransactionOnNetwork) → list[UpdateMetadataOutcome][source]

parse_wipe(transaction_on_network: TransactionOnNetwork) → list[WipeOutcome][source]

class multiversx_sdk.TokenManagementTransactionsFactory(config: TransactionsFactoryConfig, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseFactory

create_transaction_for_adding_quantity(sender: Address, token_identifier: str, token_nonce: int, quantity_to_add: int) → Transaction[source]

create_transaction_for_adding_uris(sender: Address, token_identifier: str, token_nonce: int, uris: list[str]) → Transaction[source]

create_transaction_for_burning_quantity(sender: Address, token_identifier: str, token_nonce: int, quantity_to_burn: int) → Transaction[source]

create_transaction_for_changing_sft_to_meta_esdt(sender: Address, collection: str, num_decimals: int) → Transaction[source]

create_transaction_for_changing_token_to_dynamic(sender: Address, token_identifier: str) → Transaction[source]: The following token types cannot be changed to dynamic: FungibleESDT, NonFungibleESDT, NonFungibleESDTv2

create_transaction_for_creating_nft(sender: Address, token_identifier: str, initial_quantity: int, name: str, royalties: int, hash: str, attributes: bytes, uris: list[str]) → Transaction[source]

create_transaction_for_freezing(sender: Address, user: Address, token_identifier: str) → Transaction[source]: Can be used for FungibleESDT

create_transaction_for_freezing_single_nft(sender: Address, token_identifier: str, token_nonce: int, user: Address) → Transaction[source]

create_transaction_for_issuing_fungible(sender: Address, token_name: str, token_ticker: str, initial_supply: int, num_decimals: int, can_freeze: bool, can_wipe: bool, can_pause: bool, can_change_owner: bool, can_upgrade: bool, can_add_special_roles: bool) → Transaction[source]

create_transaction_for_issuing_non_fungible(sender: Address, token_name: str, token_ticker: str, can_freeze: bool, can_wipe: bool, can_pause: bool, can_transfer_nft_create_role: bool, can_change_owner: bool, can_upgrade: bool, can_add_special_roles: bool) → Transaction[source]

create_transaction_for_issuing_semi_fungible(sender: Address, token_name: str, token_ticker: str, can_freeze: bool, can_wipe: bool, can_pause: bool, can_transfer_nft_create_role: bool, can_change_owner: bool, can_upgrade: bool, can_add_special_roles: bool) → Transaction[source]

create_transaction_for_local_burning(sender: Address, token_identifier: str, supply_to_burn: int) → Transaction[source]

create_transaction_for_local_minting(sender: Address, token_identifier: str, supply_to_mint: int) → Transaction[source]

create_transaction_for_modifying_creator(sender: Address, token_identifier: str, token_nonce: int) → Transaction[source]

create_transaction_for_modifying_royalties(sender: Address, token_identifier: str, token_nonce: int, new_royalties: int) → Transaction[source]

create_transaction_for_nft_metadata_recreate(sender: Address, token_identifier: str, token_nonce: int, new_token_name: str, new_royalties: int, new_hash: str, new_attributes: bytes, new_uris: list[str]) → Transaction[source]

create_transaction_for_pausing(sender: Address, token_identifier: str) → Transaction[source]

create_transaction_for_registering_and_setting_roles(sender: Address, token_name: str, token_ticker: str, token_type: TokenType, num_decimals: int) → Transaction[source]

create_transaction_for_registering_dynamic_and_setting_roles(sender: Address, token_name: str, token_ticker: str, token_type: TokenType, denominator: int | None = None) → Transaction[source]

create_transaction_for_registering_dynamic_token(sender: Address, token_name: str, token_ticker: str, token_type: TokenType, denominator: int | None = None) → Transaction[source]

create_transaction_for_registering_meta_esdt(sender: Address, token_name: str, token_ticker: str, num_decimals: int, can_freeze: bool, can_wipe: bool, can_pause: bool, can_transfer_nft_create_role: bool, can_change_owner: bool, can_upgrade: bool, can_add_special_roles: bool) → Transaction[source]

create_transaction_for_setting_burn_role_globally(sender: Address, token_identifier: str) → Transaction[source]

create_transaction_for_setting_new_uris(sender: Address, token_identifier: str, token_nonce: int, new_uris: list[str]) → Transaction[source]

create_transaction_for_setting_special_role_on_fungible_token(sender: Address, user: Address, token_identifier: str, add_role_local_mint: bool = False, add_role_local_burn: bool = False, add_role_esdt_transfer_role: bool = False) → Transaction[source]

create_transaction_for_setting_special_role_on_meta_esdt(sender: Address, user: Address, token_identifier: str, add_role_nft_create: bool = False, add_role_nft_burn: bool = False, add_role_nft_add_quantity: bool = False, add_role_esdt_transfer_role: bool = False) → Transaction[source]

create_transaction_for_setting_special_role_on_non_fungible_token(sender: Address, user: Address, token_identifier: str, add_role_nft_create: bool = False, add_role_nft_burn: bool = False, add_role_nft_update_attributes: bool = False, add_role_nft_add_uri: bool = False, add_role_esdt_transfer_role: bool = False, add_role_nft_update: bool = False, add_role_esdt_modify_royalties: bool = False, add_role_esdt_set_new_uri: bool = False, add_role_esdt_modify_creator: bool = False, add_role_nft_recreate: bool = False) → Transaction[source]

create_transaction_for_setting_special_role_on_semi_fungible_token(sender: Address, user: Address, token_identifier: str, add_role_nft_create: bool = False, add_role_nft_burn: bool = False, add_role_nft_add_quantity: bool = False, add_role_esdt_transfer_role: bool = False, add_role_nft_update: bool = False, add_role_esdt_modify_royalties: bool = False, add_role_esdt_set_new_uri: bool = False, add_role_esdt_modify_creator: bool = False, add_role_nft_recreate: bool = False) → Transaction[source]

create_transaction_for_stopping_nft_creation(sender: Address, token_identifier: str) → Transaction[source]

create_transaction_for_transferring_nft_create_role(sender: Address, token_identifier: str, user: Address) → Transaction[source]: This role can be transferred only if the canTransferNFTCreateRole property of the token is set to true.

create_transaction_for_transferring_ownership(sender: Address, token_identifier: str, new_owner: Address) → Transaction[source]

create_transaction_for_unfreezing(sender: Address, user: Address, token_identifier: str) → Transaction[source]: Can be used for FungibleESDT

create_transaction_for_unfreezing_single_nft(sender: Address, token_identifier: str, token_nonce: int, user: Address) → Transaction[source]

create_transaction_for_unpausing(sender: Address, token_identifier: str) → Transaction[source]

create_transaction_for_unsetting_burn_role_globally(sender: Address, token_identifier: str) → Transaction[source]

create_transaction_for_unsetting_special_role_on_fungible_token(sender: Address, user: Address, token_identifier: str, remove_role_local_mint: bool = False, remove_role_local_burn: bool = False, remove_role_esdt_transfer_role: bool = False) → Transaction[source]

create_transaction_for_unsetting_special_role_on_meta_esdt(sender: Address, user: Address, token_identifier: str, remove_role_nft_burn: bool = False, remove_role_nft_add_quantity: bool = False, remove_role_esdt_transfer_role: bool = False) → Transaction[source]

create_transaction_for_unsetting_special_role_on_non_fungible_token(sender: Address, user: Address, token_identifier: str, remove_role_nft_burn: bool = False, remove_role_nft_update_attributes: bool = False, remove_role_nft_remove_uri: bool = False, remove_role_esdt_transfer_role: bool = False, remove_role_nft_update: bool = False, remove_role_esdt_modify_royalties: bool = False, remove_role_esdt_set_new_uri: bool = False, remove_role_esdt_modify_creator: bool = False, remove_role_nft_recreate: bool = False) → Transaction[source]

create_transaction_for_unsetting_special_role_on_semi_fungible_token(sender: Address, user: Address, token_identifier: str, remove_role_nft_burn: bool = False, remove_role_nft_add_quantity: bool = False, remove_role_esdt_transfer_role: bool = False, remove_role_nft_update: bool = False, remove_role_esdt_modify_royalties: bool = False, remove_role_esdt_set_new_uri: bool = False, remove_role_esdt_modify_creator: bool = False, remove_role_nft_recreate: bool = False) → Transaction[source]

create_transaction_for_updating_attributes(sender: Address, token_identifier: str, token_nonce: int, attributes: bytes) → Transaction[source]

create_transaction_for_updating_metadata(sender: Address, token_identifier: str, token_nonce: int, new_token_name: str, new_royalties: int, new_hash: str, new_attributes: bytes, new_uris: list[str]) → Transaction[source]

create_transaction_for_updating_token_id(sender: Address, token_identifier: str) → Transaction[source]

create_transaction_for_wiping(sender: Address, user: Address, token_identifier: str) → Transaction[source]

create_transaction_for_wiping_single_nft(sender: Address, token_identifier: str, token_nonce: int, user: Address) → Transaction[source]

class multiversx_sdk.TokenManagementTransactionsOutcomeParser[source]

Bases: object

parse_add_quantity(transaction: TransactionOnNetwork) → list[AddQuantityOutcome][source]

parse_burn_quantity(transaction: TransactionOnNetwork) → list[BurnQuantityOutcome][source]

parse_change_token_to_dynamic(transaction: TransactionOnNetwork) → list[ChangeTokenToDynamicOutcome][source]

parse_freeze(transaction: TransactionOnNetwork) → list[FreezeOutcome][source]

parse_issue_fungible(transaction: TransactionOnNetwork) → list[IssueFungibleOutcome][source]

parse_issue_non_fungible(transaction: TransactionOnNetwork) → list[IssueNonFungibleOutcome][source]

parse_issue_semi_fungible(transaction: TransactionOnNetwork) → list[IssueSemiFungibleOutcome][source]

parse_local_burn(transaction: TransactionOnNetwork) → list[BurnOutcome][source]

parse_local_mint(transaction: TransactionOnNetwork) → list[MintOutcome][source]

parse_metadata_recreate(transaction: TransactionOnNetwork) → list[MetadataRecreateOutcome][source]

parse_modify_creator(transaction: TransactionOnNetwork) → list[ModifyCreatorOutcome][source]

parse_modify_royalties(transaction: TransactionOnNetwork) → list[ModifyRoyaltiesOutcome][source]

parse_nft_create(transaction: TransactionOnNetwork) → list[NFTCreateOutcome][source]

parse_pause(transaction: TransactionOnNetwork) → list[PauseOutcome][source]

parse_register_and_set_all_roles(transaction: TransactionOnNetwork) → list[RegisterAndSetAllRolesOutcome][source]

parse_register_dynamic_and_setting_roles(transaction: TransactionOnNetwork) → list[RegisterDynamicOutcome][source]

parse_register_dynamic_token(transaction: TransactionOnNetwork) → list[RegisterDynamicOutcome][source]

parse_register_meta_esdt(transaction: TransactionOnNetwork) → list[RegisterMetaEsdtOutcome][source]

parse_set_burn_role_globally(transaction: TransactionOnNetwork) → None[source]

parse_set_new_uris(transaction: TransactionOnNetwork) → list[SetNewUrisOutcome][source]

parse_set_special_role(transaction: TransactionOnNetwork) → list[SetSpecialRoleOutcome][source]

parse_unfreeze(transaction: TransactionOnNetwork) → list[UnFreezeOutcome][source]

parse_unpause(transaction: TransactionOnNetwork) → list[UnPauseOutcome][source]

parse_unset_burn_role_globally(transaction: TransactionOnNetwork) → None[source]

parse_update_attributes(transaction: TransactionOnNetwork) → list[UpdateAttributesOutcome][source]

parse_update_metadata(transaction: TransactionOnNetwork) → list[UpdateMetadataOutcome][source]

parse_wipe(transaction: TransactionOnNetwork) → list[WipeOutcome][source]

class multiversx_sdk.TokenTransfer(token: Token, amount: int)[source]

Bases: object

amount should always be in atomic units: 1.000000 “USDC-c76f1f” = “1000000

static new_from_native_amount(amount: int) → TokenTransfer[source]

class multiversx_sdk.TokenType(*values)[source]

Bases: Enum

FNG = 'FNG'

META = 'META'

NFT = 'NFT'

SFT = 'SFT'

class multiversx_sdk.TokensCollectionMetadata(raw: dict[str, Any], collection: str, type: str, name: str, ticker: str, owner: str, decimals: int)[source]

Bases: object

collection: str

decimals: int

name: str

owner: str

raw: dict[str, Any]

ticker: str

type: str

Bases: object

static new_from_dictionary(dictionary: dict[str, Any]) → Transaction[source]

to_dictionary() → dict[str, Any][source]

class multiversx_sdk.TransactionAwaiter(fetcher: ITransactionFetcher, polling_interval_in_milliseconds: int | None = None, timeout_interval_in_milliseconds: int | None = None, patience_time_in_milliseconds: int | None = None)[source]

Bases: object

TransactionAwaiter allows one to await until a specific event (such as transaction completion) occurs on a given transaction.

Args:: fetcher (ITransactionFetcher): Used to fetch the transaction of the network. polling_interval_in_milliseconds (Optional[int]): The polling interval, in milliseconds. timeout_interval_in_milliseconds (Optional[int]): The timeout, in milliseconds. patience_time_in_milliseconds (Optional[int]): The patience, an extra time (in milliseconds) to wait, after the transaction has reached its desired status. Currently there’s a delay between the moment a transaction is marked as “completed” and the moment its outcome (contract results, events and logs) is available.

await_completed(transaction_hash: str | bytes) → TransactionOnNetwork[source]: Waits until the transaction is completely processed.

await_on_condition(transaction_hash: str | bytes, condition: Callable[[TransactionOnNetwork], bool]) → TransactionOnNetwork[source]: Waits until the condition is satisfied.

class multiversx_sdk.TransactionComputer[source]

Bases: object

apply_guardian(transaction: Transaction, guardian: Address) → None[source]

apply_options_for_hash_signing(transaction: Transaction) → None[source]

compute_bytes_for_signing(transaction: Transaction, ignore_options: bool = False) → bytes[source]

If ignore_options == False, the method computes the bytes for signing based on the version and options of the transaction. If the least significant bit of the options is set, will serialize transaction for hash signing.

If ignore_options == True, the transaction is simply serialized.

compute_bytes_for_verifying(transaction: Transaction) → bytes[source]

compute_hash_for_signing(transaction: Transaction) → bytes[source]

compute_transaction_fee(transaction: Transaction, network_config: INetworkConfig) → int[source]: TransactionsFactoryConfig can be used here as the network_config.

compute_transaction_hash(transaction: Transaction) → bytes[source]

has_options_set_for_guarded_transaction(transaction: Transaction) → bool[source]

has_options_set_for_hash_signing(transaction: Transaction) → bool[source]

is_relayed_v3_transaction(transaction: Transaction) → bool[source]

class multiversx_sdk.TransactionCostResponse(raw: dict[str, Any], gas_limit: int, status: multiversx_sdk.core.transaction_status.TransactionStatus)[source]

Bases: object

gas_limit: int

raw: dict[str, Any]

status: TransactionStatus

class multiversx_sdk.TransactionDecoder[source]

Bases: object

Can be used for decoding custom token transfers transactions (ESDTTransfer, NFTTransfer, MultiESDTNFTTransfer).

get_esdt_transaction_metadata(metadata: TransactionMetadata) → TransactionMetadata | None[source]

get_multi_transfer_metadata(metadata: TransactionMetadata) → TransactionMetadata | None[source]

get_nft_transfer_metadata(metadata: TransactionMetadata) → TransactionMetadata | None[source]

get_normal_transaction_metadata(transaction: TransactionOnNetwork) → TransactionMetadata[source]

get_transaction_metadata(transaction: TransactionOnNetwork) → TransactionMetadata[source]

hex_to_number(hex: str) → int[source]

hex_to_string(hex: str) → str[source]

is_address_valid(address: str) → bool[source]

is_hex(value: str) → bool[source]

is_smart_contract_call_argument(arg: str) → bool[source]

class multiversx_sdk.TransactionEvent(raw: dict[str, Any], address: multiversx_sdk.core.address.Address, identifier: str, topics: list[bytes], data: bytes, additional_data: list[bytes])[source]

Bases: object

additional_data: list[bytes]

address: Address

data: bytes

identifier: str

raw: dict[str, Any]

topics: list[bytes]

class multiversx_sdk.TransactionEventsParser(abi: Abi, first_topic_as_identifier: bool = True)[source]

Bases: object

parse_event(event: TransactionEvent) → SimpleNamespace[source]

parse_events(events: list[TransactionEvent]) → list[SimpleNamespace][source]

class multiversx_sdk.TransactionLogs(address: multiversx_sdk.core.address.Address, events: list[multiversx_sdk.core.transaction_on_network.TransactionEvent])[source]

Bases: object

address: Address

events: list[TransactionEvent]

class multiversx_sdk.TransactionMetadata[source]

Bases: object

to_dict() → dict[str, Any][source]

transfer_messages: list[bytes]: This property is set to the extra arguments passed to ESDTTransfer when transferring tokens to non-smart contract accounts.

class multiversx_sdk.TransactionOnNetwork(raw: dict[str, Any], sender: multiversx_sdk.core.address.Address, receiver: multiversx_sdk.core.address.Address, hash: bytes, nonce: int, round: int, epoch: int, timestamp: int, block_hash: bytes, miniblock_hash: bytes, sender_shard: int, receiver_shard: int, value: int, gas_limit: int, gas_price: int, function: str, data: bytes, version: int, options: int, signature: bytes, status: multiversx_sdk.core.transaction_status.TransactionStatus, smart_contract_results: list[multiversx_sdk.core.transaction_on_network.SmartContractResult], logs: multiversx_sdk.core.transaction_on_network.TransactionLogs)[source]

Bases: object

block_hash: bytes

data: bytes

epoch: int

function: str

gas_limit: int

gas_price: int

hash: bytes

logs: TransactionLogs

miniblock_hash: bytes

nonce: int

options: int

raw: dict[str, Any]

receiver: Address

receiver_shard: int

round: int

sender: Address

sender_shard: int

signature: bytes

smart_contract_results: list[SmartContractResult]

status: TransactionStatus

timestamp: int

value: int

version: int

class multiversx_sdk.TransactionStatus(status: str)[source]

Bases: object

is_completed: bool

is_failed: bool

is_successful: bool

status: str

class multiversx_sdk.TransactionsFactoryConfig(chain_id: str, address_hrp: str = 'erd', min_gas_limit: int = 50000, gas_limit_per_byte: int = 1500, gas_limit_issue: int = 60000000, gas_limit_toggle_burn_role_globally: int = 60000000, gas_limit_esdt_local_mint: int = 300000, gas_limit_esdt_local_burn: int = 300000, gas_limit_set_special_role: int = 60000000, gas_limit_pausing: int = 60000000, gas_limit_freezing: int = 60000000, gas_limit_wiping: int = 60000000, gas_limit_esdt_nft_create: int = 3000000, gas_limit_esdt_nft_update_attributes: int = 50000, gas_limit_esdt_nft_add_quantity: int = 50000, gas_limit_esdt_nft_burn: int = 50000, gas_limit_store_per_byte: int = 10000, gas_limit_esdt_modify_royalties: int = 60000000, gas_limit_set_new_uris: int = 60000000, gas_limit_esdt_modify_creator: int = 60000000, gas_limit_esdt_metadata_update: int = 60000000, gas_limit_nft_metadata_recreate: int = 60000000, gas_limit_nft_change_to_dynamic: int = 60000000, gas_limit_update_token_id: int = 60000000, gas_limit_register_dynamic: int = 60000000, issue_cost: int = 50000000000000000, gas_limit_transfer_ownership: int = 60000000, gas_limit_freeze_single_nft: int = 60000000, gas_limit_unfreeze_single_nft: int = 60000000, gas_limit_change_sft_to_meta_esdt: int = 60000000, gas_limit_transfer_nft_create_role: int = 60000000, gas_limit_stop_nft_create: int = 60000000, gas_limit_wipe_single_nft: int = 60000000, gas_limit_esdt_nft_add_uri: int = 10000000, esdt_contract_address: multiversx_sdk.core.address.Address = <factory>, gas_limit_stake: int = 5000000, gas_limit_unstake: int = 5000000, gas_limit_unbond: int = 5000000, gas_limit_create_delegation_contract: int = 50000000, gas_limit_delegation_operations: int = 1000000, additional_gas_limit_per_validator_node: int = 6000000, additional_gas_for_delegation_operations: int = 10000000, gas_limit_esdt_transfer: int = 200000, gas_limit_esdt_nft_transfer: int = 200000, gas_limit_multi_esdt_nft_transfer: int = 200000, gas_limit_save_key_value: int = 100000, gas_limit_persist_per_byte: int = 1000, gas_limit_set_guardian: int = 250000, gas_limit_guard_account: int = 250000, gas_limit_unguard_account: int = 250000, gas_limit_claim_developer_rewards: int = 6000000, gas_limit_change_owner_address: int = 6000000, gas_limit_for_staking: int = 5000000, gas_limit_for_topping_up: int = 5000000, gas_limit_for_unstaking: int = 5000000, gas_limit_for_unjailing: int = 5000000, gas_limit_for_unbonding: int = 5000000, gas_limit_for_changing_rewards_address: int = 5000000, gas_limit_for_claiming: int = 5000000, gas_limit_for_unstaking_nodes: int = 5000000, gas_limit_for_unstaking_tokens: int = 5000000, gas_limit_for_unbonding_nodes: int = 5000000, gas_limit_for_unbonding_tokens: int = 5000000, gas_limit_for_cleaning_registered_data: int = 5000000, gas_limit_for_restaking_unstaked_tokens: int = 5000000, gas_limit_for_creating_delegation_contract_from_validator: int = 51000000, gas_limit_for_whitelist_for_merge: int = 5000000, gas_limit_for_merging_validator_to_delegation: int = 50000000)[source]

Bases: object

additional_gas_for_delegation_operations: int = 10000000

additional_gas_limit_per_validator_node: int = 6000000

address_hrp: str = 'erd'

chain_id: str

esdt_contract_address: Address

gas_limit_change_owner_address: int = 6000000

gas_limit_change_sft_to_meta_esdt: int = 60000000

gas_limit_claim_developer_rewards: int = 6000000

gas_limit_create_delegation_contract: int = 50000000

gas_limit_delegation_operations: int = 1000000

gas_limit_esdt_local_burn: int = 300000

gas_limit_esdt_local_mint: int = 300000

gas_limit_esdt_metadata_update: int = 60000000

gas_limit_esdt_modify_creator: int = 60000000

gas_limit_esdt_modify_royalties: int = 60000000

gas_limit_esdt_nft_add_quantity: int = 50000

gas_limit_esdt_nft_add_uri: int = 10000000

gas_limit_esdt_nft_burn: int = 50000

gas_limit_esdt_nft_create: int = 3000000

gas_limit_esdt_nft_transfer: int = 200000

gas_limit_esdt_nft_update_attributes: int = 50000

gas_limit_esdt_transfer: int = 200000

gas_limit_for_change_config = 50000000

gas_limit_for_changing_rewards_address: int = 5000000

gas_limit_for_claim_accumulated_fees = 1000000

gas_limit_for_claiming: int = 5000000

gas_limit_for_cleaning_registered_data: int = 5000000

gas_limit_for_clear_proposals = 50000000

gas_limit_for_closing_proposal = 50000000

gas_limit_for_creating_delegation_contract_from_validator: int = 51000000

gas_limit_for_merging_validator_to_delegation: int = 50000000

gas_limit_for_proposal = 50000000

gas_limit_for_restaking_unstaked_tokens: int = 5000000

gas_limit_for_staking: int = 5000000

gas_limit_for_topping_up: int = 5000000

gas_limit_for_unbonding: int = 5000000

gas_limit_for_unbonding_nodes: int = 5000000

gas_limit_for_unbonding_tokens: int = 5000000

gas_limit_for_unjailing: int = 5000000

gas_limit_for_unstaking: int = 5000000

gas_limit_for_unstaking_nodes: int = 5000000

gas_limit_for_unstaking_tokens: int = 5000000

gas_limit_for_vote = 5000000

gas_limit_for_whitelist_for_merge: int = 5000000

gas_limit_freeze_single_nft: int = 60000000

gas_limit_freezing: int = 60000000

gas_limit_guard_account: int = 250000

gas_limit_issue: int = 60000000

gas_limit_multi_esdt_nft_transfer: int = 200000

gas_limit_nft_change_to_dynamic: int = 60000000

gas_limit_nft_metadata_recreate: int = 60000000

gas_limit_pausing: int = 60000000

gas_limit_per_byte: int = 1500

gas_limit_persist_per_byte: int = 1000

gas_limit_register_dynamic: int = 60000000

gas_limit_save_key_value: int = 100000

gas_limit_set_guardian: int = 250000

gas_limit_set_new_uris: int = 60000000

gas_limit_set_special_role: int = 60000000

gas_limit_stake: int = 5000000

gas_limit_stop_nft_create: int = 60000000

gas_limit_store_per_byte: int = 10000

gas_limit_toggle_burn_role_globally: int = 60000000

gas_limit_transfer_nft_create_role: int = 60000000

gas_limit_transfer_ownership: int = 60000000

gas_limit_unbond: int = 5000000

gas_limit_unfreeze_single_nft: int = 60000000

gas_limit_unguard_account: int = 250000

gas_limit_unstake: int = 5000000

gas_limit_update_token_id: int = 60000000

gas_limit_wipe_single_nft: int = 60000000

gas_limit_wiping: int = 60000000

issue_cost: int = 50000000000000000

min_gas_limit: int = 50000

class multiversx_sdk.TransferTransactionsFactory(config: TransactionsFactoryConfig, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseFactory

create_transaction_for_esdt_token_transfer(sender: Address, receiver: Address, token_transfers: list[TokenTransfer], data: bytes | None = None) → Transaction[source]

create_transaction_for_native_token_transfer(sender: Address, receiver: Address, native_amount: int, data: str | None = None) → Transaction[source]

create_transaction_for_transfer(sender: Address, receiver: Address, native_amount: int | None = None, token_transfers: list[TokenTransfer] | None = None, data: bytes | None = None) → Transaction[source]

class multiversx_sdk.TransfersController(chain_id: str, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseController

create_transaction_for_esdt_token_transfer(sender: IAccount, nonce: int, receiver: Address, token_transfers: list[TokenTransfer], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_native_token_transfer(sender: IAccount, nonce: int, receiver: Address, native_transfer_amount: int = 0, data: bytes | None = None, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_transfer(sender: IAccount, nonce: int, receiver: Address, native_transfer_amount: int | None = None, token_transfers: list[TokenTransfer] | None = None, data: bytes | None = None, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

class multiversx_sdk.UnFreezeOutcome(user_address: multiversx_sdk.core.address.Address, token_identifier: str, nonce: int, balance: int)[source]

Bases: object

balance: int

nonce: int

token_identifier: str

user_address: Address

class multiversx_sdk.UnPauseOutcome(token_identifier: str)[source]

Bases: object

token_identifier: str

class multiversx_sdk.UpdateAttributesOutcome(token_identifier: str, nonce: int, attributes: bytes)[source]

Bases: object

attributes: bytes

nonce: int

token_identifier: str

class multiversx_sdk.UpdateMetadataOutcome(token_identifier: str, nonce: int, metadata: bytes)[source]

Bases: object

metadata: bytes

nonce: int

token_identifier: str

class multiversx_sdk.UserPEM(label: str, secret_key: UserSecretKey)[source]

Bases: object

classmethod from_file(path: Path, index: int = 0) → UserPEM[source]

classmethod from_file_all(path: Path) → list[UserPEM][source]

classmethod from_text(text: str, index: int = 0) → UserPEM[source]

classmethod from_text_all(text: str) → list[UserPEM][source]

save(path: Path)[source]

to_text() → str[source]

class multiversx_sdk.UserPublicKey(buffer: bytes)[source]

Bases: object

get_bytes() → bytes[source]

hex() → str[source]

to_address(hrp: str | None = None) → Address[source]

verify(data: bytes, signature: bytes) → bool[source]

class multiversx_sdk.UserRole(*values)[source]

Bases: Enum

BOARD_MEMBER = 2

NONE = 0

PROPOSER = 1

class multiversx_sdk.UserSecretKey(buffer: bytes)[source]

Bases: object

classmethod generate() → UserSecretKey[source]

generate_public_key() → UserPublicKey[source]

get_bytes() → bytes[source]

hex() → str[source]

classmethod new_from_string(buffer_hex: str) → UserSecretKey[source]

sign(data: bytes) → bytes[source]

class multiversx_sdk.UserSigner(secret_key: UserSecretKey)[source]

Bases: object

ed25519 signer

classmethod from_pem_file(path: Path, index: int = 0) → UserSigner[source]

classmethod from_pem_file_all(path: Path) → list[UserSigner][source]

classmethod from_wallet(path: Path, password: str) → UserSigner[source]

get_pubkey() → UserPublicKey[source]

sign(data: bytes) → bytes[source]

class multiversx_sdk.UserVerifier(public_key: UserPublicKey)[source]

Bases: object

classmethod from_address(address: Address) → UserVerifier[source]

verify(data: bytes, signature: bytes) → bool[source]

class multiversx_sdk.UserWallet(kind: str, encrypted_data: EncryptedData, public_key_when_kind_is_secret_key: UserPublicKey | None = None)[source]

Bases: object

Do not use this constructor directly. Use the static methods from_secret_key() and from_mnemonic() instead.

classmethod decrypt_mnemonic(keyfile_object: dict[str, Any], password: str) → Mnemonic[source]

classmethod decrypt_secret_key(keyfile_object: dict[str, Any], password: str) → UserSecretKey[source]

classmethod from_mnemonic(mnemonic: str, password: str, randomness: IRandomness | None = None) → UserWallet[source]

classmethod from_secret_key(secret_key: UserSecretKey, password: str, randomness: IRandomness | None = None) → UserWallet[source]

classmethod load_secret_key(path: Path, password: str, address_index: int | None = None) → UserSecretKey[source]

Loads a secret key from a keystore file.

Parameters:

path – The path to the keystore file.
password – The password to decrypt the keystore file.
address_index – The index of the address to load. This is only used when the keystore file contains a mnemonic, and the secret key has to be derived from this mnemonic.

save(path: Path, address_hrp: str | None = None)[source]

to_dict(address_hrp: str | None = None) → dict[str, Any][source]

to_json(address_hrp: str | None = None) → str[source]

class multiversx_sdk.ValidatorPEM(label: str, secret_key: ValidatorSecretKey)[source]

Bases: object

classmethod from_file(path: Path, index: int = 0) → ValidatorPEM[source]

classmethod from_file_all(path: Path) → list[ValidatorPEM][source]

classmethod from_text(text: str, index: int = 0) → ValidatorPEM[source]

classmethod from_text_all(text: str) → list[ValidatorPEM][source]

save(path: Path)[source]

to_text()[source]

class multiversx_sdk.ValidatorPublicKey(buffer: bytes)[source]

Bases: object

classmethod from_string(buffer_hex: str) → ValidatorPublicKey[source]

hex() → str[source]

verify(data: bytes, signature: bytes) → bool[source]

class multiversx_sdk.ValidatorSecretKey(buffer: bytes)[source]

Bases: object

classmethod from_string(buffer_hex: str) → ValidatorSecretKey[source]

classmethod generate() → ValidatorSecretKey[source]

generate_public_key() → ValidatorPublicKey[source]

hex() → str[source]

sign(data: bytes) → bytes[source]

class multiversx_sdk.ValidatorSigner(secret_key: ValidatorSecretKey)[source]

Bases: object

Validator signer (BLS signer)

classmethod from_pem_file(path: Path, index: int = 0) → ValidatorSigner[source]

get_pubkey() → ValidatorPublicKey[source]

sign(data: bytes) → bytes[source]

class multiversx_sdk.ValidatorVerifier(public_key: ValidatorPublicKey)[source]

Bases: object

classmethod from_string(buffer_hex: str) → ValidatorVerifier[source]

verify(data: bytes, signature: bytes) → bool[source]

class multiversx_sdk.ValidatorsController(chain_id: str, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseController

create_transaction_for_changing_rewards_address(sender: IAccount, nonce: int, rewards_address: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_claiming(sender: IAccount, nonce: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_cleaning_registered_data(sender: IAccount, nonce: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_merging_validator_to_delegation_same_owner(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_merging_validator_to_delegation_with_whitelist(sender: IAccount, nonce: int, delegation_contract: Address, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_new_delegation_contract_from_validator_data(sender: IAccount, nonce: int, max_cap: int, fee: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_restaking_unstaked_nodes(sender: IAccount, nonce: int, public_keys: list[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_staking(sender: IAccount, nonce: int, validators_file: Path | ValidatorsSigners, amount: int, rewards_address: Address | None = None, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_topping_up(sender: IAccount, nonce: int, amount: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unbonding(sender: IAccount, nonce: int, public_keys: list[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unbonding_nodes(sender: IAccount, nonce: int, public_keys: list[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unbonding_tokens(sender: IAccount, nonce: int, amount: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unjailing(sender: IAccount, nonce: int, public_keys: list[ValidatorPublicKey], amount: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unstaking(sender: IAccount, nonce: int, public_keys: list[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unstaking_nodes(sender: IAccount, nonce: int, public_keys: list[ValidatorPublicKey], guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

create_transaction_for_unstaking_tokens(sender: IAccount, nonce: int, amount: int, guardian: Address | None = None, relayer: Address | None = None, gas_limit: int | None = None, gas_price: int | None = None) → Transaction[source]

class multiversx_sdk.ValidatorsSigners(validator_signers: list[ValidatorSigner])[source]

Bases: object

get_num_of_nodes() → int[source]

get_public_keys() → list[ValidatorPublicKey][source]

get_signers() → list[ValidatorSigner][source]

static new_from_pem(file: Path) → ValidatorsSigners[source]

class multiversx_sdk.ValidatorsTransactionsFactory(config: TransactionsFactoryConfig, gas_limit_estimator: IGasLimitEstimator | None = None)[source]

Bases: BaseFactory

create_transaction_for_changing_rewards_address(sender: Address, rewards_address: Address) → Transaction[source]

create_transaction_for_claiming(sender: Address) → Transaction[source]

create_transaction_for_cleaning_registered_data(sender: Address) → Transaction[source]

create_transaction_for_merging_validator_to_delegation_same_owner(sender: Address, delegation_contract: Address) → Transaction[source]

create_transaction_for_merging_validator_to_delegation_with_whitelist(sender: Address, delegation_contract: Address) → Transaction[source]

create_transaction_for_new_delegation_contract_from_validator_data(sender: Address, max_cap: int, fee: int) → Transaction[source]

create_transaction_for_restaking_unstaked_nodes(sender: Address, public_keys: list[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_staking(sender: Address, validators_file: Path | ValidatorsSigners, amount: int, rewards_address: Address | None = None) → Transaction[source]

create_transaction_for_topping_up(sender: Address, amount: int) → Transaction[source]

create_transaction_for_unbonding(sender: Address, public_keys: list[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_unbonding_nodes(sender: Address, public_keys: list[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_unbonding_tokens(sender: Address, amount: int) → Transaction[source]

create_transaction_for_unjailing(sender: Address, public_keys: list[ValidatorPublicKey], amount: int) → Transaction[source]

create_transaction_for_unstaking(sender: Address, public_keys: list[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_unstaking_nodes(sender: Address, public_keys: list[ValidatorPublicKey]) → Transaction[source]

create_transaction_for_unstaking_tokens(sender: Address, amount: int) → Transaction[source]

class multiversx_sdk.VoteOutcome(proposal_nonce: int, vote: str, total_stake: int, total_voting_power: int)[source]

Bases: object

proposal_nonce: int

total_stake: int

total_voting_power: int

vote: str

class multiversx_sdk.VoteType(*values)[source]

Bases: Enum

ABSTAIN = 'abstain'

NO = 'no'

VETO = 'veto'

YES = 'yes'

class multiversx_sdk.WipeOutcome(user_address: multiversx_sdk.core.address.Address, token_identifier: str, nonce: int, balance: int)[source]

Bases: object

balance: int

nonce: int

token_identifier: str

user_address: Address

multiversx_sdk.find_events_by_first_topic(transaction: TransactionOnNetwork, topic: str) → list[TransactionEvent][source]

multiversx_sdk.find_events_by_identifier(transaction: TransactionOnNetwork, identifier: str) → list[TransactionEvent][source]