Skip to main content

iota_wallet.account

Account Objects​

class Account()

build_alias_output​

def build_alias_output(amount, native_tokens, alias_id, state_index,
                       state_metadata, foundry_counter, unlock_conditions,
                       features, immutable_features)

Build alias output.

build_basic_output​

def build_basic_output(amount, native_tokens, unlock_conditions, features)

Build basic output.

build_foundry_output​

def build_foundry_output(amount, native_tokens, serial_number, token_scheme,
                         unlock_conditions, features, immutable_features)

Build foundry output.

build_nft_output​

def build_nft_output(amount, native_tokens, nft_id, unlock_conditions,
                     features, immutable_features)

BuildNftOutput.

burn_native_token​

def burn_native_token(token_id, burn_amount, options=None)

Burn native tokens. This doesn't require the foundry output which minted them, but will not increase the foundries melted_tokens field, which makes it impossible to destroy the foundry output. Therefore it's recommended to use melting, if the foundry output is available.

burn_nft​

def burn_nft(nft_id, options=None)

Burn an nft output. Outputs controlled by it will be swept before if they don't have a storage deposit return, timelock or expiration unlock condition. This should be preferred over burning, because after burning, the foundry can never be destroyed anymore.

consolidate_outputs​

def consolidate_outputs(force, output_consolidation_threshold)

Consolidate outputs.

create_alias_output​

def create_alias_output(alias_output_options, options)

Create an alias output.

destroy_alias​

def destroy_alias(alias_id, options=None)

Destroy an alias output. Outputs controlled by it will be swept before if they don't have a storage deposit return, timelock or expiration unlock condition. The amount and possible native tokens will be sent to the governor address.

destroy_foundry​

def destroy_foundry(foundry_id, options=None)

Destroy a foundry output with a circulating supply of 0. Native tokens in the foundry (minted by other foundries) will be transacted to the controlling alias

generate_addresses​

def generate_addresses(amount, options=None)

Generate new addresses.

get_outputs_with_additional_unlock_conditions​

def get_outputs_with_additional_unlock_conditions(outputs_to_claim)

Get outputs with additional unlock conditions.

get_output​

def get_output(output_id)

Get output.

get_transaction​

def get_transaction(transaction_id)

Get transaction.

addresses​

def addresses()

List addresses.

addresses_with_unspent_outputs​

def addresses_with_unspent_outputs()

Returns only addresses of the account with unspent outputs.

outputs​

def outputs(filter_options=None)

Returns all outputs of the account.

unspent_outputs​

def unspent_outputs(filter_options=None)

Returns all unspent outputs of the account.

incoming_transactions​

def incoming_transactions()

Returns all incoming transactions of the account.

transactions​

def transactions()

Returns all transaction of the account.

pending_transactions​

def pending_transactions()

Returns all pending transactions of the account.

decrease_native_token_supply​

def decrease_native_token_supply(token_id, melt_amount, options=None)

Melt native tokens. This happens with the foundry output which minted them, by increasing it's melted_tokens field.

increase_native_token_supply​

def increase_native_token_supply(token_id,
                                 mint_amount,
                                 increase_native_token_supply_options=None,
                                 options=None)

Mint more native token.

mint_native_token​

def mint_native_token(native_token_options, options=None)

Mint native token.

minimum_required_storage_deposit​

def minimum_required_storage_deposit(output)

Minimum required storage deposit.

mint_nfts​

def mint_nfts(nfts_options, options=None)

Mint nfts.

get_balance​

def get_balance()

Get account balance information.

prepare_send_amount​

def prepare_send_amount(addresses_with_amount, options=None)

Prepare send amount.

prepare_transaction​

def prepare_transaction(outputs, options=None)

Prepare transaction.

retry_transaction_until_included​

def retry_transaction_until_included(transaction_id,
                                     interval=None,
                                     max_attempts=None)

Retries (promotes or reattaches) a transaction sent from the account for a provided transaction id until it's included (referenced by a milestone). Returns the included block id.

sync​

def sync(options=None)

Sync the account by fetching new information from the nodes. Will also retry pending transactions and consolidate outputs if necessary.

send_amount​

def send_amount(addresses_with_amount, options=None)

Send amount.

send_micro_transaction​

def send_micro_transaction(addresses_with_micro_amount, options=None)

Send micro transaction.

send_native_tokens​

def send_native_tokens(addresses_native_tokens, options=None)

Send native tokens.

send_nft​

def send_nft(addresses_nft_ids, options=None)

Send nft.

set_alias​

def set_alias(alias)

Set alias.

sign_transaction_essence​

def sign_transaction_essence(prepared_transaction_data)

Sign a transaction essence.

submit_and_store_transaction​

def submit_and_store_transaction(signed_transaction_data)

Submit and store transaction.

claim_outputs​

def claim_outputs(output_ids_to_claim)

Claim outputs.

send_outputs​

@send_message_routine
def send_outputs(outputs, options=None)

Send outputs in a transaction.

request_funds_from_faucet​

def request_funds_from_faucet(url=None, address=None)

Requests funds from the faucet