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: [...],
   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

Register an online key.

• 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’
  ’ * 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

Register an offline key.

• Parameters:

  • params – Key registration parameters
  • send_params – Send parameters

• Returns: Result of the registration transaction

• Example:

  # 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)