transactions.transaction_sender | Algorand Developer Portal

transactions.transaction_sender

Classes

`SendSingleTransactionResult`	Base class for transaction results.
`SendSingleAssetCreateTransactionResult`	Result of creating a new ASA (Algorand Standard Asset).
`SendAppTransactionResult`	Result of an application transaction.
`SendAppUpdateTransactionResult`	Result of updating an application.
`SendAppCreateTransactionResult`	Result of creating a new application.
`AlgorandClientTransactionSender`	Orchestrates sending transactions for AlgorandClient.

Module Contents

class algokit_utils.transactions.transaction_sender.SendSingleTransactionResult

Base class for transaction results.

Represents the result of sending a single transaction.

transaction : algokit_utils.models.transaction.TransactionWrapper

The last transaction

confirmation : algosdk.v2client.algod.AlgodResponseType

The last confirmation

group_id: str_

The group ID

tx_id: str | None = None_

The transaction ID

tx_ids: list[str]_

The full array of transaction IDs

transactions : list[algokit_utils.models.transaction.TransactionWrapper]

The full array of transactions

confirmations : list[algosdk.v2client.algod.AlgodResponseType]

The full array of confirmations

returns : list[algokit_utils.applications.abi.ABIReturn] | None = None

The ABI return value if applicable

classmethod from_composer_result(result: algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults, *, is_abi: bool = False, index: int = -1) → typing_extensions.Self

class algokit_utils.transactions.transaction_sender.SendSingleAssetCreateTransactionResult

Bases: SendSingleTransactionResult

Result of creating a new ASA (Algorand Standard Asset).

Contains the asset ID of the newly created asset.

asset_id: int_

The ID of the newly created asset

class algokit_utils.transactions.transaction_sender.SendAppTransactionResult

Bases: SendSingleTransactionResult, Generic[ABIReturnT

Result of an application transaction.

Contains the ABI return value if applicable.

abi_return: ABIReturnT | None = None_

The ABI return value if applicable

class algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult

Bases: SendAppTransactionResult[ABIReturnT

Result of updating an application.

Contains the compiled approval and clear programs.

compiled_approval: Any | None = None_

The compiled approval program

compiled_clear: Any | None = None_

The compiled clear state program

class algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult

Bases: SendAppUpdateTransactionResult[ABIReturnT

Result of creating a new application.

Contains the app ID and address of the newly created application.

app_id: int_

The ID of the newly created application

app_address: str_

The address of the newly created application

class algokit_utils.transactions.transaction_sender.AlgorandClientTransactionSender(new_group: collections.abc.Callable[[], algokit_utils.transactions.transaction_composer.TransactionComposer], asset_manager: algokit_utils.assets.asset_manager.AssetManager, app_manager: algokit_utils.applications.app_manager.AppManager, algod_client: algosdk.v2client.algod.AlgodClient)

Orchestrates sending transactions for AlgorandClient.

Provides methods to send various types of transactions including payments, asset operations, and application calls.

new_group() → algokit_utils.transactions.transaction_composer.TransactionComposer

Create a new transaction group.

Returns:
A new TransactionComposer instance
Example:

sender = AlgorandClientTransactionSender(new_group, asset_manager, app_manager, algod_client)

composer = sender.new_group()

composer(PaymentParams(sender="sender", receiver="receiver", amount=AlgoAmount(algo=1)))

composer.send()

payment(params: algokit_utils.transactions.transaction_composer.PaymentParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleTransactionResult

Send a payment transaction to transfer Algo between accounts.

Parameters:
- params – Payment transaction parameters
- send_params – Send parameters
Returns: Result of the payment transaction
Example:

result = algorand.send.payment(PaymentParams(

sender="SENDERADDRESS",

receiver="RECEIVERADDRESS",

amount=AlgoAmount(algo=4),

))

# Advanced example

result = algorand.send.payment(PaymentParams(

amount=AlgoAmount(algo=4),

receiver="RECEIVERADDRESS",

sender="SENDERADDRESS",

close_remainder_to="CLOSEREMAINDERTOADDRESS",

lease="lease",

note="note",

rekey_to="REKEYTOADDRESS",

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

max_fee=AlgoAmount(micro_algo=3000),

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

asset_create(params: algokit_utils.transactions.transaction_composer.AssetCreateParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleAssetCreateTransactionResult

Create a new Algorand Standard Asset.

Parameters:
- params – Asset creation parameters
- send_params – Send parameters
Returns: Result containing the new asset ID
Example:

result = algorand.send.asset_create(AssetCreateParams(

sender="SENDERADDRESS",

asset_name="ASSETNAME",

unit_name="UNITNAME",

total=1000,
))

# Advanced example

result = algorand.send.asset_create(AssetCreateParams(

sender="CREATORADDRESS",

total=100,

decimals=2,

asset_name="asset",

unit_name="unit",

url="url",

metadata_hash="metadataHash",

default_frozen=False,

manager="MANAGERADDRESS",

reserve="RESERVEADDRESS",

freeze="FREEZEADDRESS",

clawback="CLAWBACKADDRESS",

lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

asset_config(params: algokit_utils.transactions.transaction_composer.AssetConfigParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleTransactionResult

Configure an existing Algorand Standard Asset.

Parameters:
- params – Asset configuration parameters
- send_params – Send parameters
Returns: Result of the configuration transaction
Example:

result = algorand.send.asset_config(AssetConfigParams(

sender="MANAGERADDRESS",

asset_id=123456,

manager="MANAGERADDRESS",

reserve="RESERVEADDRESS",

freeze="FREEZEADDRESS",

clawback="CLAWBACKADDRESS",

lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

asset_freeze(params: algokit_utils.transactions.transaction_composer.AssetFreezeParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleTransactionResult

Freeze or unfreeze an Algorand Standard Asset for an account.

Parameters:
- params – Asset freeze parameters
- send_params – Send parameters
Returns: Result of the freeze transaction
Example:

result = algorand.send.asset_freeze(AssetFreezeParams(

sender="MANAGERADDRESS",

asset_id=123456,

account="ACCOUNTADDRESS",

frozen=True,
))

# Advanced example

result = algorand.send.asset_freeze(AssetFreezeParams(

sender="MANAGERADDRESS",

asset_id=123456,

account="ACCOUNTADDRESS",

frozen=True,
lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

asset_destroy(params: algokit_utils.transactions.transaction_composer.AssetDestroyParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleTransactionResult

Destroys an Algorand Standard Asset.

Parameters:
- params – Asset destruction parameters
- send_params – Send parameters
Returns: Result of the destroy transaction
Example:

result = algorand.send.asset_destroy(AssetDestroyParams(

sender="MANAGERADDRESS",

asset_id=123456,
))

# Advanced example

result = algorand.send.asset_destroy(AssetDestroyParams(

sender="MANAGERADDRESS",

asset_id=123456,

lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

asset_transfer(params: algokit_utils.transactions.transaction_composer.AssetTransferParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleTransactionResult

Transfer an Algorand Standard Asset.

Parameters:
- params – Asset transfer parameters
- send_params – Send parameters
Returns: Result of the transfer transaction
Example:

result = algorand.send.asset_transfer(AssetTransferParams(

sender="HOLDERADDRESS",

asset_id=123456,

amount=1,

receiver="RECEIVERADDRESS",
))

# Advanced example (with clawback)

result = algorand.send.asset_transfer(AssetTransferParams(

sender="CLAWBACKADDRESS",

asset_id=123456,

amount=1,

receiver="RECEIVERADDRESS",

clawback_target="HOLDERADDRESS",

# This field needs to be used with caution

close_asset_to="ADDRESSTOCLOSETO",

lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

asset_opt_in(params: algokit_utils.transactions.transaction_composer.AssetOptInParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleTransactionResult

Opt an account into an Algorand Standard Asset.

Parameters:
- params – Asset opt-in parameters
- send_params – Send parameters
Returns: Result of the opt-in transaction
Example:

result = algorand.send.asset_opt_in(AssetOptInParams(

sender="SENDERADDRESS",

asset_id=123456,
))

# Advanced example

result = algorand.send.asset_opt_in(AssetOptInParams(

sender="SENDERADDRESS",

asset_id=123456,

lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

asset_opt_out(params: algokit_utils.transactions.transaction_composer.AssetOptOutParams, send_params: algokit_utils.models.transaction.SendParams | None = None, *, ensure_zero_balance: bool = True) → SendSingleTransactionResult

Opt an account out of an Algorand Standard Asset.

Parameters:
- params – Asset opt-out parameters
- send_params – Send parameters
- ensure_zero_balance – Check if account has zero balance before opt-out, defaults to True
Raises: ValueError – If account has non-zero balance or is not opted in
Returns: Result of the opt-out transaction
Example:

result = algorand.send.asset_opt_out(AssetOptOutParams(

sender="SENDERADDRESS",

creator="CREATORADDRESS",

asset_id=123456,
ensure_zero_balance=True,
))

# Advanced example

result = algorand.send.asset_opt_out(AssetOptOutParams(

sender="SENDERADDRESS",

asset_id=123456,

creator="CREATORADDRESS",
ensure_zero_balance=True,
lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

app_create(params: algokit_utils.transactions.transaction_composer.AppCreateParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendAppCreateTransactionResult[algokit_utils.applications.abi.ABIReturn]

Create a new application.

Parameters:
- params – Application creation parameters
- send_params – Send parameters
Returns: Result containing the new application ID and address
Example:

result = algorand.send.app_create(AppCreateParams(

sender="CREATORADDRESS",

approval_program="TEALCODE",

clear_state_program="TEALCODE",
))

# Advanced example

result = algorand.send.app_create(AppCreateParams(

sender="CREATORADDRESS",

approval_program="TEALCODE",

clear_state_program="TEALCODE",
))

# algorand.send.appCreate(AppCreateParams(
#  sender='CREATORADDRESS',
#  approval_program="TEALCODE",
#  clear_state_program="TEALCODE",
#  schema={
#    "global_ints": 1,
#    "global_byte_slices": 2,
#    "local_ints": 3,
#    "local_byte_slices": 4
#  },
#  extra_program_pages: 1,
#  on_complete: algosdk.transaction.OnComplete.OptInOC,
#  args: [b'some_bytes']
#  account_references: ["ACCOUNT_1"]
#  app_references: [123, 1234]
#  asset_references: [12345]
#  box_references: ["box1", {app_id: 1234, name: "box2"}]
#  lease: 'lease',
#  note: 'note',
#  # You wouldn't normally set this field
#  first_valid_round: 1000,
#  validity_window: 10,
#  extra_fee: AlgoAmount(micro_algo=1000),
#  static_fee: AlgoAmount(micro_algo=1000),
#  # Max fee doesn't make sense with extraFee AND staticFee
#  #  already specified, but here for completeness
#  max_fee: AlgoAmount(micro_algo=3000),
#  # Signer only needed if you want to provide one,
#  # generally you'd register it with AlgorandClient
#  # against the sender and not need to pass it in
#  signer: transactionSigner
#}, send_params=SendParams(
#  max_rounds_to_wait_for_confirmation=5,
#  suppress_log=True,
#))

app_update(params: algokit_utils.transactions.transaction_composer.AppUpdateParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendAppUpdateTransactionResult[algokit_utils.applications.abi.ABIReturn]

Update an application.

Parameters:
- params – Application update parameters
- send_params – Send parameters
Returns: Result containing the compiled programs
Example:

# Basic example

algorand.send.app_update(AppUpdateParams(

sender="CREATORADDRESS",

approval_program="TEALCODE",

clear_state_program="TEALCODE",
))

# Advanced example

algorand.send.app_update(AppUpdateParams(

sender="CREATORADDRESS",

approval_program="TEALCODE",

clear_state_program="TEALCODE",

on_complete=OnComplete.UpdateApplicationOC,

args=[b'some_bytes'],

account_references=["ACCOUNT_1"],

app_references=[123, 1234],

asset_references=[12345],

box_references=[...],

lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

app_delete(params: algokit_utils.transactions.transaction_composer.AppDeleteParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendAppTransactionResult[algokit_utils.applications.abi.ABIReturn]

Delete an application.

Parameters:
- params – Application deletion parameters
- send_params – Send parameters
Returns: Result of the deletion transaction
Example:

# Basic example

algorand.send.app_delete(AppDeleteParams(

sender="CREATORADDRESS",

app_id=123456,
))

# Advanced example

algorand.send.app_delete(AppDeleteParams(

sender="CREATORADDRESS",

on_complete=OnComplete.DeleteApplicationOC,

args=[b'some_bytes'],

account_references=["ACCOUNT_1"],

app_references=[123, 1234],

asset_references=[12345],

box_references=[...],

lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner,
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

app_call(params: algokit_utils.transactions.transaction_composer.AppCallParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendAppTransactionResult[algokit_utils.applications.abi.ABIReturn]

Call an application.

Parameters:
- params – Application call parameters
- send_params – Send parameters
Returns: Result containing any ABI return value
Example:

# Basic example

algorand.send.app_call(AppCallParams(

sender="CREATORADDRESS",

app_id=123456,
))

# Advanced example

algorand.send.app_call(AppCallParams(

sender="CREATORADDRESS",

on_complete=OnComplete.OptInOC,

args=[b'some_bytes'],

account_references=["ACCOUNT_1"],

app_references=[123, 1234],

asset_references=[12345],

box_references=[...],

lease="lease",

note="note",

# You wouldn't normally set this field

first_valid_round=1000,

validity_window=10,

extra_fee=AlgoAmount(micro_algo=1000),

static_fee=AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee=AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer=transactionSigner,
), send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

app_create_method_call(params: algokit_utils.transactions.transaction_composer.AppCreateMethodCallParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendAppCreateTransactionResult[algokit_utils.applications.abi.ABIReturn]

Call an application’s create method.

Parameters:
- params – Method call parameters for application creation
- send_params – Send parameters
Returns: Result containing the new application ID and address
Example:

# Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.

# @param params The parameters for the app creation transaction

# Basic example

method = algorand.abi.Method(

name='method',

args=[b'arg1'],

returns='string'
)

result = algorand.send.app_create_method_call({ sender: 'CREATORADDRESS',
    approval_program: 'TEALCODE',
    clear_state_program: 'TEALCODE',
    method: method,
    args: ["arg1_value"] })

created_app_id = result.app_id

...

# Advanced example

method = algorand.abi.Method(

name='method',

args=[b'arg1'],

returns='string'
)

result = algorand.send.app_create_method_call({

sender: 'CREATORADDRESS',

method: method,

args: ["arg1_value"],

approval_program: "TEALCODE",

clear_state_program: "TEALCODE",

schema: {
     "global_ints": 1,
     "global_byte_slices": 2,
     "local_ints": 3,
     "local_byte_slices": 4
},

extra_program_pages: 1,

on_complete: algosdk.transaction.OnComplete.OptInOC,

args: [new Uint8Array(1, 2, 3, 4)],

account_references: ["ACCOUNT_1"],

app_references: [123, 1234],

asset_references: [12345],

box_references: ["box1", {app_id: 1234, name: "box2"}],

lease: 'lease',

note: 'note',

# You wouldn't normally set this field

first_valid_round: 1000,

validity_window: 10,

extra_fee: AlgoAmount(micro_algo=1000),

static_fee: AlgoAmount(micro_algo=1000),

# Max fee doesn't make sense with extraFee AND staticFee

# already specified, but here for completeness

max_fee: AlgoAmount(micro_algo=3000),

# Signer only needed if you want to provide one,

# generally you'd register it with AlgorandClient

# against the sender and not need to pass it in

signer: transactionSigner,
}, send_params=SendParams(

max_rounds_to_wait_for_confirmation=5,

suppress_log=True,
))

app_update_method_call(params: algokit_utils.transactions.transaction_composer.AppUpdateMethodCallParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendAppUpdateTransactionResult[algokit_utils.applications.abi.ABIReturn]

Call an application’s update method.

Parameters:
- params – Method call parameters for application update
- send_params – Send parameters
Returns: Result containing the compiled programs
Example:

# Basic example:

method = algorand.abi.Method(

name="updateMethod",

args=[{"type": "string", "name": "arg1"}],

returns="string"
)

params = AppUpdateMethodCallParams(

sender="CREATORADDRESS",

app_id=123,

method=method,

args=["new_value"],

approval_program="TEALCODE",

clear_state_program="TEALCODE"
)

result = algorand.send.app_update_method_call(params)

print(result.compiled_approval, result.compiled_clear)

# Advanced example:

method = algorand.abi.Method(

name="updateMethod",

args=[{"type": "string", "name": "arg1"}, {"type": "uint64", "name": "arg2"}],

returns="string"
)

params = AppUpdateMethodCallParams(

sender="CREATORADDRESS",

app_id=456,

method=method,

args=["new_value", 42],

approval_program="TEALCODE_ADVANCED",

clear_state_program="TEALCLEAR_ADVANCED",

account_references=["ACCOUNT1", "ACCOUNT2"],

app_references=[789],

asset_references=[101112]
)

result = algorand.send.app_update_method_call(params)

print(result.compiled_approval, result.compiled_clear)

app_delete_method_call(params: algokit_utils.transactions.transaction_composer.AppDeleteMethodCallParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendAppTransactionResult[algokit_utils.applications.abi.ABIReturn]

Call an application’s delete method.

Parameters:
- params – Method call parameters for application deletion
- send_params – Send parameters
Returns: Result of the deletion transaction
Example:

# Basic example:

method = algorand.abi.Method(

name="deleteMethod",

args=[],

returns="void"
)

params = AppDeleteMethodCallParams(

sender="CREATORADDRESS",

app_id=123,

method=method
)

result = algorand.send.app_delete_method_call(params)

print(result.tx_id)

# Advanced example:

method = algorand.abi.Method(

name="deleteMethod",

args=[{"type": "uint64", "name": "confirmation"}],

returns="void"
)

params = AppDeleteMethodCallParams(

sender="CREATORADDRESS",

app_id=123,

method=method,

args=[1],

account_references=["ACCOUNT1"],

app_references=[456]
)

result = algorand.send.app_delete_method_call(params)

print(result.tx_id)

app_call_method_call(params: algokit_utils.transactions.transaction_composer.AppCallMethodCallParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendAppTransactionResult[algokit_utils.applications.abi.ABIReturn]

Call an application’s call method.

Parameters:
- params – Method call parameters
- send_params – Send parameters
Returns: Result containing any ABI return value
Example:

# Basic example:

method = algorand.abi.Method(

name="callMethod",

args=[{"type": "uint64", "name": "arg1"}],

returns="uint64"
)

params = AppCallMethodCallParams(

sender="CALLERADDRESS",

app_id=123,

method=method,

args=[12345]
)

result = algorand.send.app_call_method_call(params)

print(result.abi_return)

# Advanced example:

method = algorand.abi.Method(

name="callMethod",

args=[{"type": "uint64", "name": "arg1"}, {"type": "string", "name": "arg2"}],

returns="uint64"
)

params = AppCallMethodCallParams(

sender="CALLERADDRESS",

app_id=123,

method=method,

args=[12345, "extra"],

account_references=["ACCOUNT1"],

asset_references=[101112],

app_references=[789]
)

result = algorand.send.app_call_method_call(params)

print(result.abi_return)

online_key_registration(params: algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleTransactionResult

Parameters:
- params – Key registration parameters
- send_params – Send parameters
Returns: Result of the registration transaction
Example:

# Basic example:

params = OnlineKeyRegistrationParams(

sender="ACCOUNTADDRESS",

vote_key="VOTEKEY",

selection_key="SELECTIONKEY",

vote_first=1000,

vote_last=2000,

vote_key_dilution=10
)

result = algorand.send.online_key_registration(params)

print(result.tx_id)

# Advanced example:

params = OnlineKeyRegistrationParams(

sender="ACCOUNTADDRESS",

vote_key="VOTEKEY",

selection_key="SELECTIONKEY",

vote_first=1000,

vote_last=2100,

vote_key_dilution=10,

state_proof_key=b'\x01' * 64
)

result = algorand.send.online_key_registration(params)

print(result.tx_id)

offline_key_registration(params: algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams, send_params: algokit_utils.models.transaction.SendParams | None = None) → SendSingleTransactionResult

# Basic example:

params = OfflineKeyRegistrationParams(

sender="ACCOUNTADDRESS",

prevent_account_from_ever_participating_again=True
)

result = algorand.send.offline_key_registration(params)

print(result.tx_id)

# Advanced example:

params = OfflineKeyRegistrationParams(

sender="ACCOUNTADDRESS",

prevent_account_from_ever_participating_again=True,

note=b'Offline registration'
)

result = algorand.send.offline_key_registration(params)

print(result.tx_id)