algokit_utils.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 SendSingleTransactionResult

Base class for transaction results.

Represents the result of sending a single transaction.

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[TransactionWrapper]

The full array of transactions

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

The full array of confirmations

returns : list[ABIReturn] | None = None

The ABI return value if applicable

classmethod from_composer_result(result: SendAtomicTransactionComposerResults, , is_abi: bool = False, index: int = -1) → Self

class 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 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 SendAppUpdateTransactionResult

Bases: SendAppTransactionResult[ABIReturnT]

Result of updating an application.

Contains the compiled approval and clear programs.

compiled_approval : CompiledTeal | bytes | None = None

The compiled approval program

compiled_clear : CompiledTeal | bytes | None = None

The compiled clear state program

class 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 AlgorandClientTransactionSender

Orchestrates sending transactions for AlgorandClient.

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

new_group() → 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: PaymentParams, send_params: 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: AssetCreateParams, send_params: 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: AssetConfigParams, send_params: 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: AssetFreezeParams, send_params: 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: AssetDestroyParams, send_params: 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: AssetTransferParams, send_params: 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: AssetOptInParams, send_params: 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: AssetOptOutParams, send_params: 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: AppCreateParams, send_params: SendParams | None = None) → SendAppCreateTransactionResult[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: AppUpdateParams, send_params: SendParams | None = None) → SendAppUpdateTransactionResult[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: AppDeleteParams, send_params: SendParams | None = None) → SendAppTransactionResult[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: AppCallParams, send_params: SendParams | None = None) → SendAppTransactionResult[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: AppCreateMethodCallParams, send_params: SendParams | None = None) → SendAppCreateTransactionResult[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: AppUpdateMethodCallParams, send_params: SendParams | None = None) → SendAppUpdateTransactionResult[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: AppDeleteMethodCallParams, send_params: SendParams | None = None) → SendAppTransactionResult[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: AppCallMethodCallParams, send_params: SendParams | None = None) → SendAppTransactionResult[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: OnlineKeyRegistrationParams, send_params: 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: OfflineKeyRegistrationParams, send_params: 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)