algokit-utils 3.0.0b4__py3-none-any.whl → 3.0.0b6__py3-none-any.whl

algokit_utils/_legacy_v2/account.py

@@ -177,10 +177,10 @@ def get_account(
     For LocalNet environments, loads or creates an account from a KMD wallet named {name}.
 
     :example:
-    >>> # If you have a mnemonic secret loaded into `os.environ["ACCOUNT_MNEMONIC"]` then you can call:
-    >>> account = get_account('ACCOUNT', algod)
-    >>> # If that code runs against LocalNet then a wallet called 'ACCOUNT' will automatically be created
-    >>> # with an account that is automatically funded with 1000 (default) ALGOs from the default LocalNet dispenser.
+        >>> # If you have a mnemonic secret loaded into `os.environ["ACCOUNT_MNEMONIC"]` then you can call:
+        >>> account = get_account('ACCOUNT', algod)
+        >>> # If that code runs against LocalNet then a wallet called 'ACCOUNT' will automatically be created
+        >>> # with an account that is automatically funded with 1000 (default) ALGOs from the default LocalNet dispenser.
 
     :param client: The Algorand client to use
     :param name: The name identifier to use for loading/creating the account

algokit_utils/_legacy_v2/application_client.py

@@ -74,6 +74,7 @@ __all__ = [
 representing an ABI method name or signature"""
 
 
+@deprecated("Use 'algokit_utils.calculate_extra_program_pages' instead.")
 def num_extra_program_pages(approval: bytes, clear: bytes) -> int:
     """Calculate minimum number of extra_pages required for provided approval and clear programs"""
 

algokit_utils/accounts/account_manager.py

@@ -148,7 +148,7 @@ class AccountManager:
     :param client_manager: The ClientManager client to use for algod and kmd clients
 
     :example:
-    >>> account_manager = AccountManager(client_manager)
+        >>> account_manager = AccountManager(client_manager)
     """
 
     def __init__(self, client_manager: ClientManager):
@@ -172,11 +172,11 @@ class AccountManager:
         :returns: The `AccountManager` so method calls can be chained
 
         :example:
-        >>> signer_account = account_manager.random()
-        >>> account_manager.set_default_signer(signer_account.signer)
-        >>> # When signing a transaction, if there is no signer registered for the sender
-        >>> # then the default signer will be used
-        >>> signer = account_manager.get_signer("{SENDERADDRESS}")
+            >>> signer_account = account_manager.random()
+            >>> account_manager.set_default_signer(signer_account.signer)
+            >>> # When signing a transaction, if there is no signer registered for the sender
+            >>> # then the default signer will be used
+            >>> signer = account_manager.get_signer("{SENDERADDRESS}")
         """
         self._default_signer = signer if isinstance(signer, TransactionSigner) else signer.signer
         return self
@@ -190,7 +190,7 @@ class AccountManager:
         :returns: The `AccountManager` instance for method chaining
 
         :example:
-        >>> account_manager.set_signer("SENDERADDRESS", transaction_signer)
+            >>> account_manager.set_signer("SENDERADDRESS", transaction_signer)
         """
         self._accounts[sender] = TransactionSignerAccount(address=sender, signer=signer)
         return self
@@ -221,11 +221,11 @@ class AccountManager:
         :returns: The `AccountManager` instance for method chaining
 
         :example:
-        >>> account_manager = AccountManager(client_manager)
-        >>> account_manager.set_signer_from_account(SigningAccount(private_key=algosdk.account.generate_account()[0]))
-        >>> account_manager.set_signer_from_account(LogicSigAccount(AlgosdkLogicSigAccount(program, args)))
-        >>> account_manager.set_signer_from_account(MultiSigAccount(multisig_params, [account1, account2]))
-        """
+            >>> account_manager = AccountManager(client_manager)
+            >>> account_manager.set_signer_from_account(SigningAccount(private_key=algosdk.account.generate_account()[0]))
+            >>> account_manager.set_signer_from_account(LogicSigAccount(AlgosdkLogicSigAccount(program, args)))
+            >>> account_manager.set_signer_from_account(MultiSigAccount(multisig_params, [account1, account2]))
+        """  # noqa: E501
         self._accounts[account.address] = account
         return self
 
@@ -240,7 +240,7 @@ class AccountManager:
         :raises ValueError: If no signer is found and no default signer is set
 
         :example:
-        >>> signer = account_manager.get_signer("SENDERADDRESS")
+            >>> signer = account_manager.get_signer("SENDERADDRESS")
         """
         signer = self._accounts.get(self._get_address(sender)) or self._default_signer
         if not signer:
@@ -256,10 +256,10 @@ class AccountManager:
         :raises ValueError: If no account is found or if the account is not a regular account
 
         :example:
-        >>> sender = account_manager.random().address
-        >>> # ...
-        >>> # Returns the `TransactionSignerAccountProtocol` for `sender` that has previously been registered
-        >>> account = account_manager.get_account(sender)
+            >>> sender = account_manager.random().address
+            >>> # ...
+            >>> # Returns the `TransactionSignerAccountProtocol` for `sender` that has previously been registered
+            >>> account = account_manager.get_account(sender)
         """
         account = self._accounts.get(sender)
         if not account:
@@ -279,8 +279,8 @@ class AccountManager:
         :returns: The account information
 
         :example:
-        >>> address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA"
-        >>> account_info = account_manager.get_information(address)
+            >>> address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA"
+            >>> account_info = account_manager.get_information(address)
         """
         info = self._client_manager.algod.account_info(self._get_address(sender))
         assert isinstance(info, dict)
@@ -342,7 +342,7 @@ class AccountManager:
             from the environment (ideally via a secret storage service) rather than the file system.
 
         :example:
-        >>> account = account_manager.from_mnemonic("mnemonic secret ...")
+            >>> account = account_manager.from_mnemonic("mnemonic secret ...")
         """
         return self._register_account(to_private_key(mnemonic), sender)
 
@@ -355,7 +355,7 @@ class AccountManager:
 
         :param name: The name identifier of the account
         :param fund_with: Optional amount to fund the account with when it gets created
-        (when targeting LocalNet)
+            (when targeting LocalNet)
         :returns: The account
         :raises ValueError: If environment variable {NAME}_MNEMONIC is missing when looking for account {NAME}
 
@@ -368,10 +368,10 @@ class AccountManager:
                   it will create it and fund the account for you
 
         :example:
-        >>> # If you have a mnemonic secret loaded into `MY_ACCOUNT_MNEMONIC` then you can call:
-        >>> account = account_manager.from_environment('MY_ACCOUNT')
-        >>> # If that code runs against LocalNet then a wallet called `MY_ACCOUNT` will automatically be created
-        >>> # with an account that is automatically funded with the specified amount from the default LocalNet dispenser
+            >>> # If you have a mnemonic secret loaded into `MY_ACCOUNT_MNEMONIC` then you can call:
+            >>> account = account_manager.from_environment('MY_ACCOUNT')
+            >>> # If that code runs against LocalNet then a wallet called `MY_ACCOUNT` will automatically be created
+            >>> # with an account that is automatically funded with the specified amount from the LocalNet dispenser
         """
         account_mnemonic = os.getenv(f"{name.upper()}_MNEMONIC")
 
@@ -398,10 +398,10 @@ class AccountManager:
         :raises ValueError: If unable to find KMD account with given name and predicate
 
         :example:
-        >>> # Get default funded account in a LocalNet:
-        >>> defaultDispenserAccount = account.from_kmd('unencrypted-default-wallet',
-        ...     lambda a: a.status != 'Offline' and a.amount > 1_000_000_000
-        ... )
+            >>> # Get default funded account in a LocalNet:
+            >>> defaultDispenserAccount = account.from_kmd('unencrypted-default-wallet',
+            ...     lambda a: a.status != 'Offline' and a.amount > 1_000_000_000
+            ... )
         """
         kmd_account = self._kmd_account_manager.get_wallet_account(name, predicate, sender)
         if not kmd_account:
@@ -418,7 +418,7 @@ class AccountManager:
         :returns: A logic signature account wrapper
 
         :example:
-        >>> account = account.logic_sig(program, [new Uint8Array(3, ...)])
+            >>> account = account.logic_sig(program, [new Uint8Array(3, ...)])
         """
         return self._register_logicsig(program, args)
 
@@ -431,12 +431,12 @@ class AccountManager:
         :returns: A multisig account wrapper
 
         :example:
-        >>> account = account_manager.multi_sig(
-        ...     version=1,
-        ...     threshold=1,
-        ...     addrs=["ADDRESS1...", "ADDRESS2..."],
-        ...     signing_accounts=[account1, account2]
-        ... )
+            >>> account = account_manager.multi_sig(
+            ...     version=1,
+            ...     threshold=1,
+            ...     addrs=["ADDRESS1...", "ADDRESS2..."],
+            ...     signing_accounts=[account1, account2]
+            ... )
         """
         return self._register_multisig(metadata, signing_accounts)
 
@@ -447,7 +447,7 @@ class AccountManager:
         :returns: The account
 
         :example:
-        >>> account = account_manager.random()
+            >>> account = account_manager.random()
         """
         private_key, _ = algosdk.account.generate_account()
         return self._register_account(private_key)
@@ -461,7 +461,7 @@ class AccountManager:
         :returns: The account
 
         :example:
-        >>> account = account_manager.localnet_dispenser()
+            >>> account = account_manager.localnet_dispenser()
         """
         kmd_account = self._kmd_account_manager.get_localnet_dispenser_account()
         return self._register_account(kmd_account.private_key)
@@ -475,7 +475,7 @@ class AccountManager:
         :returns: The account
 
         :example:
-        >>> account = account_manager.dispenser_from_environment()
+            >>> account = account_manager.dispenser_from_environment()
         """
         name = os.getenv(f"{DISPENSER_ACCOUNT_NAME}_MNEMONIC")
         if name:
@@ -493,8 +493,8 @@ class AccountManager:
         :returns: The rekeyed account
 
         :example:
-        >>> account = account.from_mnemonic("mnemonic secret ...")
-        >>> rekeyed_account = account_manager.rekeyed(account, "SENDERADDRESS...")
+            >>> account = account.from_mnemonic("mnemonic secret ...")
+            >>> rekeyed_account = account_manager.rekeyed(account, "SENDERADDRESS...")
         """
         sender_address = sender.address if isinstance(sender, SigningAccount) else sender
         self._accounts[sender_address] = TransactionSignerAccount(address=sender_address, signer=account.signer)
@@ -540,23 +540,23 @@ class AccountManager:
             `official rekey guidance <https://developer.algorand.org/docs/get-details/accounts/rekey/>`_.
 
         :example:
-        >>> # Basic example (with string addresses):
-        >>> algorand.account.rekey_account({account: "ACCOUNTADDRESS", rekey_to: "NEWADDRESS"})
-        >>> # Basic example (with signer accounts):
-        >>> algorand.account.rekey_account({account: account1, rekey_to: newSignerAccount})
-        >>> # Advanced example:
-        >>> algorand.account.rekey_account({
-        ...     account: "ACCOUNTADDRESS",
-        ...     rekey_to: "NEWADDRESS",
-        ...     lease: 'lease',
-        ...     note: 'note',
-        ...     first_valid_round: 1000,
-        ...     validity_window: 10,
-        ...     extra_fee: AlgoAmount.from_micro_algo(1000),
-        ...     static_fee: AlgoAmount.from_micro_algo(1000),
-        ...     max_fee: AlgoAmount.from_micro_algo(3000),
-        ...     suppress_log: True,
-        ... })
+            >>> # Basic example (with string addresses):
+            >>> algorand.account.rekey_account({account: "ACCOUNTADDRESS", rekey_to: "NEWADDRESS"})
+            >>> # Basic example (with signer accounts):
+            >>> algorand.account.rekey_account({account: account1, rekey_to: newSignerAccount})
+            >>> # Advanced example:
+            >>> algorand.account.rekey_account({
+            ...     account: "ACCOUNTADDRESS",
+            ...     rekey_to: "NEWADDRESS",
+            ...     lease: 'lease',
+            ...     note: 'note',
+            ...     first_valid_round: 1000,
+            ...     validity_window: 10,
+            ...     extra_fee: AlgoAmount.from_micro_algo(1000),
+            ...     static_fee: AlgoAmount.from_micro_algo(1000),
+            ...     max_fee: AlgoAmount.from_micro_algo(3000),
+            ...     suppress_log: True,
+            ... })
         """
         sender_address = self._get_address(account)
         rekey_address = self._get_address(rekey_to)
@@ -623,7 +623,7 @@ class AccountManager:
         :param account_to_fund: The account to fund
         :param dispenser_account: The account to use as a dispenser funding source
         :param min_spending_balance: The minimum balance of Algo that the account
-        should have available to spend
+            should have available to spend
         :param min_funding_increment: Optional minimum funding increment
         :param send_params: Parameters for the send operation, defaults to None
         :param signer: Optional transaction signer
@@ -637,20 +637,20 @@ class AccountManager:
         :param first_valid_round: Optional first valid round
         :param last_valid_round: Optional last valid round
         :returns: The result of executing the dispensing transaction and the `amountFunded` if funds were needed,
-        or None if no funds were needed
+            or None if no funds were needed
 
         :example:
-        >>> # Basic example:
-        >>> algorand.account.ensure_funded("ACCOUNTADDRESS", "DISPENSERADDRESS", algokit.algo(1))
-        >>> # With configuration:
-        >>> algorand.account.ensure_funded(
-        ...     "ACCOUNTADDRESS",
-        ...     "DISPENSERADDRESS",
-        ...     algokit.algo(1),
-        ...     min_funding_increment=algokit.algo(2),
-        ...     fee=AlgoAmount.from_micro_algo(1000),
-        ...     suppress_log=True
-        ... )
+            >>> # Basic example:
+            >>> algorand.account.ensure_funded("ACCOUNTADDRESS", "DISPENSERADDRESS", algokit.algo(1))
+            >>> # With configuration:
+            >>> algorand.account.ensure_funded(
+            ...     "ACCOUNTADDRESS",
+            ...     "DISPENSERADDRESS",
+            ...     algokit.algo(1),
+            ...     min_funding_increment=algokit.algo(2),
+            ...     fee=AlgoAmount.from_micro_algo(1000),
+            ...     suppress_log=True
+            ... )
         """
         account_to_fund = self._get_address(account_to_fund)
         dispenser_account = self._get_address(dispenser_account)
@@ -724,7 +724,7 @@ class AccountManager:
 
         :param account_to_fund: The account to fund
         :param min_spending_balance: The minimum balance of Algo that the account should have available to
-        spend
+            spend
         :param min_funding_increment: Optional minimum funding increment
         :param send_params: Parameters for the send operation, defaults to None
         :param signer: Optional transaction signer
@@ -738,7 +738,7 @@ class AccountManager:
         :param first_valid_round: Optional first valid round
         :param last_valid_round: Optional last valid round
         :returns: The result of executing the dispensing transaction and the `amountFunded` if funds were needed, or
-        None if no funds were needed
+            None if no funds were needed
 
         .. note::
             The dispenser account is retrieved from the account mnemonic stored in
@@ -746,16 +746,16 @@ class AccountManager:
             if it's a rekeyed account, or against default LocalNet if no environment variables present.
 
         :example:
-        >>> # Basic example:
-        >>> algorand.account.ensure_funded_from_environment("ACCOUNTADDRESS", algokit.algo(1))
-        >>> # With configuration:
-        >>> algorand.account.ensure_funded_from_environment(
-        ...     "ACCOUNTADDRESS",
-        ...     algokit.algo(1),
-        ...     min_funding_increment=algokit.algo(2),
-        ...     fee=AlgoAmount.from_micro_algo(1000),
-        ...     suppress_log=True
-        ... )
+            >>> # Basic example:
+            >>> algorand.account.ensure_funded_from_environment("ACCOUNTADDRESS", algokit.algo(1))
+            >>> # With configuration:
+            >>> algorand.account.ensure_funded_from_environment(
+            ...     "ACCOUNTADDRESS",
+            ...     algokit.algo(1),
+            ...     min_funding_increment=algokit.algo(2),
+            ...     fee=AlgoAmount.from_micro_algo(1000),
+            ...     suppress_log=True
+            ... )
         """
         account_to_fund = self._get_address(account_to_fund)
         dispenser_account = self.dispenser_from_environment()
@@ -818,26 +818,26 @@ class AccountManager:
         :param account_to_fund: The account to fund
         :param dispenser_client: The TestNet dispenser funding client
         :param min_spending_balance: The minimum balance of Algo that the account should have
-        available to spend
+            available to spend
         :param min_funding_increment: Optional minimum funding increment
         :returns: The result of executing the dispensing transaction and the `amountFunded` if funds were needed, or
-        None if no funds were needed
+            None if no funds were needed
         :raises ValueError: If attempting to fund on non-TestNet network
 
         :example:
-        >>> # Basic example:
-        >>> algorand.account.ensure_funded_from_testnet_dispenser_api(
-        ...     "ACCOUNTADDRESS",
-        ...     algorand.client.get_testnet_dispenser_from_environment(),
-        ...     algokit.algo(1)
-        ... )
-        >>> # With configuration:
-        >>> algorand.account.ensure_funded_from_testnet_dispenser_api(
-        ...     "ACCOUNTADDRESS",
-        ...     algorand.client.get_testnet_dispenser_from_environment(),
-        ...     algokit.algo(1),
-        ...     min_funding_increment=algokit.algo(2)
-        ... )
+            >>> # Basic example:
+            >>> algorand.account.ensure_funded_from_testnet_dispenser_api(
+            ...     "ACCOUNTADDRESS",
+            ...     algorand.client.get_testnet_dispenser_from_environment(),
+            ...     algokit.algo(1)
+            ... )
+            >>> # With configuration:
+            >>> algorand.account.ensure_funded_from_testnet_dispenser_api(
+            ...     "ACCOUNTADDRESS",
+            ...     algorand.client.get_testnet_dispenser_from_environment(),
+            ...     algokit.algo(1),
+            ...     min_funding_increment=algokit.algo(2)
+            ... )
         """
         account_to_fund = self._get_address(account_to_fund)
 

algokit_utils/accounts/kmd_account_manager.py

@@ -48,6 +48,8 @@ class KmdAccountManager:
         if self._kmd is None:
             if self._client_manager.is_localnet():
                 kmd_config = ClientManager.get_config_from_environment_or_localnet()
+                if not kmd_config.kmd_config:
+                    raise Exception("Attempt to use KMD client with no KMD configured")
                 self._kmd = ClientManager.get_kmd_client(kmd_config.kmd_config)
                 return self._kmd
             raise Exception("Attempt to use KMD client with no KMD configured")

algokit_utils/applications/app_client.py

@@ -5,7 +5,7 @@ import copy
 import json
 import os
 from collections.abc import Sequence
-from dataclasses import asdict, dataclass, fields
+from dataclasses import asdict, dataclass, fields, replace
 from typing import TYPE_CHECKING, Any, Generic, Literal, TypedDict, TypeVar
 
 import algosdk
@@ -54,6 +54,7 @@ from algokit_utils.transactions.transaction_composer import (
     AppUpdateParams,
     BuiltTransactions,
     PaymentParams,
+    SendAtomicTransactionComposerResults,
 )
 from algokit_utils.transactions.transaction_sender import (
     SendAppTransactionResult,
@@ -1189,28 +1190,51 @@ class _TransactionSender:
         :param params: Parameters for the application call including method and transaction options
         :param send_params: Send parameters
         :return: The result of sending or simulating the transaction, including ABI return value if applicable
+        :raises ValueError: If the transaction is read-only and `max_fee` is not provided
         """
         is_read_only_call = (
             params.on_complete == algosdk.transaction.OnComplete.NoOpOC or params.on_complete is None
         ) and self._app_spec.get_arc56_method(params.method).readonly
 
         if is_read_only_call:
+            readonly_params = params
+            readonly_send_params = send_params or SendParams()
+
+            # Read-only calls do not require fees to be paid, as they are only simulated on the network.
+            # Therefore there is no value in calculating the minimum fee needed for a successful app call with inners.
+            # As a a result we only need to send a single simulate call,
+            # however to do this successfully we need to ensure fees for the transaction are fully covered using maxFee.
+            if readonly_send_params.get("cover_app_call_inner_transaction_fees"):
+                if params.max_fee is None:
+                    raise ValueError(
+                        "Please provide a `max_fee` for the transaction when `cover_app_call_inner_transaction_fees` is enabled."  # noqa: E501
+                    )
+                readonly_params = replace(readonly_params, static_fee=params.max_fee, extra_fee=None)
+
             method_call_to_simulate = self._algorand.new_group().add_app_call_method_call(
-                self._client.params.call(params)
-            )
-            send_params = send_params or SendParams()
-            simulate_response = self._client._handle_call_errors(
-                lambda: method_call_to_simulate.simulate(
-                    allow_unnamed_resources=send_params.get("populate_app_call_resources") or True,
-                    skip_signatures=True,
-                    allow_more_logs=True,
-                    allow_empty_signatures=True,
-                    extra_opcode_budget=None,
-                    exec_trace_config=None,
-                    simulation_round=None,
-                )
+                self._client.params.call(readonly_params)
             )
 
+            def run_simulate() -> SendAtomicTransactionComposerResults:
+                try:
+                    return method_call_to_simulate.simulate(
+                        allow_unnamed_resources=readonly_send_params.get("populate_app_call_resources") or True,
+                        skip_signatures=True,
+                        allow_more_logs=True,
+                        allow_empty_signatures=True,
+                        extra_opcode_budget=None,
+                        exec_trace_config=None,
+                        simulation_round=None,
+                    )
+                except Exception as e:
+                    if readonly_send_params.get("cover_app_call_inner_transaction_fees") and "fee too small" in str(e):
+                        raise ValueError(
+                            "Fees were too small. You may need to increase the transaction `maxFee`."
+                        ) from e
+                    raise
+
+            simulate_response = self._client._handle_call_errors(run_simulate)
+
             return SendAppTransactionResult[Arc56ReturnValueType](
                 tx_ids=simulate_response.tx_ids,
                 transactions=simulate_response.transactions,

algokit_utils/applications/app_deployer.py

@@ -21,6 +21,7 @@ from algokit_utils.transactions.transaction_composer import (
     AppUpdateMethodCallParams,
     AppUpdateParams,
     TransactionComposer,
+    calculate_extra_program_pages,
 )
 from algokit_utils.transactions.transaction_sender import (
     AlgorandClientTransactionSender,
@@ -169,7 +170,7 @@ class AppDeployer:
             f"{'teal code' if isinstance(deployment.create_params.approval_program, str) else 'AVM bytecode'} and "
             f"{len(deployment.create_params.clear_state_program)} bytes of "
             f"{'teal code' if isinstance(deployment.create_params.clear_state_program, str) else 'AVM bytecode'}",
-            suppress_log=suppress_log,
+            extra={"suppress_log": suppress_log},
         )
         note = TransactionComposer.arc2_note(
             {
@@ -242,9 +243,13 @@ class AppDeployer:
 
         existing_approval = base64.b64encode(existing_app_record.approval_program).decode()
         existing_clear = base64.b64encode(existing_app_record.clear_state_program).decode()
+        existing_extra_pages = calculate_extra_program_pages(
+            existing_app_record.approval_program, existing_app_record.clear_state_program
+        )
 
         new_approval = base64.b64encode(approval_program).decode()
         new_clear = base64.b64encode(clear_program).decode()
+        new_extra_pages = calculate_extra_program_pages(approval_program, clear_program)
 
         is_update = new_approval != existing_approval or new_clear != existing_clear
         is_schema_break = (
@@ -256,6 +261,7 @@ class AppDeployer:
             < (deployment.create_params.schema.get("local_byte_slices", 0) if deployment.create_params.schema else 0)
             or existing_app_record.global_byte_slices
             < (deployment.create_params.schema.get("global_byte_slices", 0) if deployment.create_params.schema else 0)
+            or existing_extra_pages < new_extra_pages
         )
 
         if is_schema_break:
@@ -269,8 +275,8 @@ class AppDeployer:
                         "local_byte_slices": existing_app_record.local_byte_slices,
                     },
                     "to": deployment.create_params.schema,
+                    "suppress_log": suppress_log,
                 },
-                suppress_log=suppress_log,
             )
 
             return self._handle_schema_break(
@@ -288,7 +294,7 @@ class AppDeployer:
                 clear_program=clear_program,
             )
 
-        logger.debug("No detected changes in app, nothing to do.", suppress_log=suppress_log)
+        logger.debug("No detected changes in app, nothing to do.", extra={"suppress_log": suppress_log})
         return AppDeployResult(
             app=existing_app,
             operation_performed=OperationPerformed.Nothing,
@@ -340,6 +346,12 @@ class AppDeployer:
         )
 
         self._update_app_lookup(deployment.create_params.sender, app_metadata)
+        logger.debug(
+            f"Sent transaction ID {create_result.app_id} (AppCreate) from {deployment.create_params.sender}",
+            extra={
+                "suppress_log": deployment.send_params.get("suppress_log") or False if deployment.send_params else False
+            },
+        )
 
         return AppDeployResult(
             app=app_metadata,
@@ -412,6 +424,13 @@ class AppDeployer:
             deleted=False,
         )
         self._update_app_lookup(deployment.create_params.sender, app_metadata)
+        logger.debug(
+            f"Group transaction sent: Replaced app {existing_app.app_id} with new app {app_id} from "
+            f"{deployment.create_params.sender} (Composer group count: {composer.count()})",
+            extra={
+                "suppress_log": deployment.send_params.get("suppress_log") or False if deployment.send_params else False
+            },
+        )
 
         return AppDeployResult(
             app=app_metadata,
@@ -464,6 +483,12 @@ class AppDeployer:
         )
 
         self._update_app_lookup(deployment.create_params.sender, app_metadata)
+        logger.debug(
+            f"Sent transaction ID {existing_app.app_id} (AppUpdate) from {deployment.create_params.sender}",
+            extra={
+                "suppress_log": deployment.send_params.get("suppress_log") or False if deployment.send_params else False
+            },
+        )
 
         return AppDeployResult(
             app=app_metadata,
@@ -491,7 +516,10 @@ class AppDeployer:
         if existing_app.deletable:
             return self._replace_app(deployment, existing_app, approval_program, clear_program)
         else:
-            raise ValueError("App is not deletable but onSchemaBreak=ReplaceApp, " "cannot delete and recreate app")
+            raise ValueError(
+                f"App is {'not' if not existing_app.deletable else ''} deletable and onSchemaBreak=ReplaceApp, "
+                "cannot delete and recreate app"
+            )
 
     def _handle_update(
         self,
@@ -512,13 +540,19 @@ class AppDeployer:
             if existing_app.updatable:
                 return self._update_app(deployment, existing_app, approval_program, clear_program)
             else:
-                raise ValueError("App is not updatable but onUpdate=UpdateApp, cannot update app")
+                raise ValueError(
+                    f"App is {'not' if not existing_app.updatable else ''} updatable and onUpdate=UpdateApp, "
+                    "cannot update app"
+                )
 
         if deployment.on_update in (OnUpdate.ReplaceApp, "replace"):
             if existing_app.deletable:
                 return self._replace_app(deployment, existing_app, approval_program, clear_program)
             else:
-                raise ValueError("App is not deletable but onUpdate=ReplaceApp, " "cannot delete and recreate app")
+                raise ValueError(
+                    f"App is {'not' if not existing_app.deletable else ''} deletable and onUpdate=ReplaceApp, "
+                    "cannot delete and recreate app"
+                )
 
         raise ValueError(f"Unsupported onUpdate value: {deployment.on_update}")
 

algokit_utils/assets/asset_manager.py

@@ -43,13 +43,13 @@ class AssetInformation:
     :ivar decimals: The amount of decimal places the asset was created with
     :ivar default_frozen: Whether the asset was frozen by default for all accounts, defaults to None
     :ivar manager: The address of the optional account that can manage the configuration of the asset and destroy it,
-    defaults to None
+        defaults to None
     :ivar reserve: The address of the optional account that holds the reserve (uncirculated supply) units of the asset,
-    defaults to None
+        defaults to None
     :ivar freeze: The address of the optional account that can be used to freeze or unfreeze holdings of this asset,
-    defaults to None
+        defaults to None
     :ivar clawback: The address of the optional account that can clawback holdings of this asset from any account,
-    defaults to None
+        defaults to None
     :ivar unit_name: The optional name of the unit of this asset (e.g. ticker name), defaults to None
     :ivar unit_name_b64: The optional name of the unit of this asset as bytes, defaults to None
     :ivar asset_name: The optional name of the asset, defaults to None
@@ -57,7 +57,7 @@ class AssetInformation:
     :ivar url: Optional URL where more information about the asset can be retrieved, defaults to None
     :ivar url_b64: Optional URL where more information about the asset can be retrieved as bytes, defaults to None
     :ivar metadata_hash: 32-byte hash of some metadata that is relevant to the asset and/or asset holders,
-    defaults to None
+        defaults to None
     """
 
     asset_id: int