algokit_utils.transactions.transaction_sender ============================================= .. py:module:: algokit_utils.transactions.transaction_sender Classes ------- .. autoapisummary:: algokit_utils.transactions.transaction_sender.SendSingleTransactionResult algokit_utils.transactions.transaction_sender.SendSingleAssetCreateTransactionResult algokit_utils.transactions.transaction_sender.SendAppTransactionResult algokit_utils.transactions.transaction_sender.SendAppUpdateTransactionResult algokit_utils.transactions.transaction_sender.SendAppCreateTransactionResult algokit_utils.transactions.transaction_sender.AlgorandClientTransactionSender Module Contents --------------- .. py:class:: SendSingleTransactionResult Base class for transaction results. Represents the result of sending a single transaction. .. py:attribute:: transaction :type: algokit_utils.models.transaction.TransactionWrapper The last transaction .. py:attribute:: confirmation :type: algosdk.v2client.algod.AlgodResponseType The last confirmation .. py:attribute:: group_id :type: str The group ID .. py:attribute:: tx_id :type: str | None :value: None The transaction ID .. py:attribute:: tx_ids :type: list[str] The full array of transaction IDs .. py:attribute:: transactions :type: list[algokit_utils.models.transaction.TransactionWrapper] The full array of transactions .. py:attribute:: confirmations :type: list[algosdk.v2client.algod.AlgodResponseType] The full array of confirmations .. py:attribute:: returns :type: list[algokit_utils.applications.abi.ABIReturn] | None :value: None The ABI return value if applicable .. py:method:: from_composer_result(result: algokit_utils.transactions.transaction_composer.SendAtomicTransactionComposerResults, index: int = -1) -> typing_extensions.Self :classmethod: .. py:class:: SendSingleAssetCreateTransactionResult Bases: :py:obj:`SendSingleTransactionResult` Result of creating a new ASA (Algorand Standard Asset). Contains the asset ID of the newly created asset. .. py:attribute:: asset_id :type: int The ID of the newly created asset .. py:class:: SendAppTransactionResult Bases: :py:obj:`SendSingleTransactionResult`, :py:obj:`Generic`\ [\ :py:obj:`ABIReturnT`\ ] Result of an application transaction. Contains the ABI return value if applicable. .. py:attribute:: abi_return :type: ABIReturnT | None :value: None The ABI return value if applicable .. py:class:: SendAppUpdateTransactionResult Bases: :py:obj:`SendAppTransactionResult`\ [\ :py:obj:`ABIReturnT`\ ] Result of updating an application. Contains the compiled approval and clear programs. .. py:attribute:: compiled_approval :type: Any | None :value: None The compiled approval program .. py:attribute:: compiled_clear :type: Any | None :value: None The compiled clear state program .. py:class:: SendAppCreateTransactionResult Bases: :py:obj:`SendAppUpdateTransactionResult`\ [\ :py:obj:`ABIReturnT`\ ] Result of creating a new application. Contains the app ID and address of the newly created application. .. py:attribute:: app_id :type: int The ID of the newly created application .. py:attribute:: app_address :type: str The address of the newly created application .. py:class:: 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. .. py:method:: new_group() -> algokit_utils.transactions.transaction_composer.TransactionComposer Create a new transaction group. :return: 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() .. py:method:: 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. :param params: Payment transaction parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Asset creation parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Asset configuration parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Asset freeze parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: asset_destroy(params: algokit_utils.transactions.transaction_composer.AssetDestroyParams, send_params: algokit_utils.models.transaction.SendParams | None = None) -> SendSingleTransactionResult Destroys an Algorand Standard Asset. :param params: Asset destruction parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: asset_transfer(params: algokit_utils.transactions.transaction_composer.AssetTransferParams, send_params: algokit_utils.models.transaction.SendParams | None = None) -> SendSingleTransactionResult Transfer an Algorand Standard Asset. :param params: Asset transfer parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Asset opt-in parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Asset opt-out parameters :param send_params: Send parameters :param 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 :return: 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, >>> )) .. py:method:: 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. :param params: Application creation parameters :param send_params: Send parameters :return: 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, >>> #)) .. py:method:: 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. :param params: Application update parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Application deletion parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Application call parameters :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Method call parameters for application creation :param send_params: Send parameters :return: 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, >>> )) .. py:method:: 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. :param params: Method call parameters for application update :param send_params: Send parameters :return: 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) .. py:method:: 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. :param params: Method call parameters for application deletion :param send_params: Send parameters :return: 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) .. py:method:: 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. :param params: Method call parameters :param send_params: Send parameters :return: 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) .. py:method:: online_key_registration(params: algokit_utils.transactions.transaction_composer.OnlineKeyRegistrationParams, send_params: algokit_utils.models.transaction.SendParams | None = None) -> SendSingleTransactionResult Register an online key. :param params: Key registration parameters :param send_params: Send parameters :return: 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) .. py:method:: offline_key_registration(params: algokit_utils.transactions.transaction_composer.OfflineKeyRegistrationParams, send_params: algokit_utils.models.transaction.SendParams | None = None) -> SendSingleTransactionResult Register an offline key. :param params: Key registration parameters :param send_params: Send parameters :return: 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)