algokit-utils 3.0.0b4__py3-none-any.whl → 3.0.0b5__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/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/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

algokit_utils/clients/client_manager.py

@@ -77,8 +77,8 @@ def _get_config_from_environment(environment_prefix: str) -> AlgoClientNetworkCo
     port = os.getenv(f"{environment_prefix}_PORT")
     if port:
         parsed = parse.urlparse(server)
-        server = parsed._replace(netloc=f"{parsed.hostname}:{port}").geturl()
-    return AlgoClientNetworkConfig(server, os.getenv(f"{environment_prefix}_TOKEN", ""))
+        server = parsed._replace(netloc=f"{parsed.hostname}").geturl()
+    return AlgoClientNetworkConfig(server, os.getenv(f"{environment_prefix}_TOKEN", ""), port=port)
 
 
 class ClientManager:
@@ -351,15 +351,18 @@ class ClientManager:
         )
 
     @staticmethod
-    def get_algod_client(config: AlgoClientNetworkConfig | None = None) -> AlgodClient:
+    def get_algod_client(config: AlgoClientNetworkConfig) -> AlgodClient:
         """Get an Algod client from config or environment.
 
         :param config: Optional client configuration
         :return: Algod client instance
         """
-        config = config or _get_config_from_environment("ALGOD")
         headers = {"X-Algo-API-Token": config.token or ""}
-        return AlgodClient(algod_token=config.token or "", algod_address=config.server, headers=headers)
+        return AlgodClient(
+            algod_token=config.token or "",
+            algod_address=config.full_url(),
+            headers=headers,
+        )
 
     @staticmethod
     def get_algod_client_from_environment() -> AlgodClient:
@@ -370,14 +373,13 @@ class ClientManager:
         return ClientManager.get_algod_client(ClientManager.get_algod_config_from_environment())
 
     @staticmethod
-    def get_kmd_client(config: AlgoClientNetworkConfig | None = None) -> KMDClient:
+    def get_kmd_client(config: AlgoClientNetworkConfig) -> KMDClient:
         """Get a KMD client from config or environment.
 
         :param config: Optional client configuration
         :return: KMD client instance
         """
-        config = config or _get_config_from_environment("KMD")
-        return KMDClient(config.token, config.server)
+        return KMDClient(config.token, config.full_url())
 
     @staticmethod
     def get_kmd_client_from_environment() -> KMDClient:
@@ -388,15 +390,18 @@ class ClientManager:
         return ClientManager.get_kmd_client(ClientManager.get_kmd_config_from_environment())
 
     @staticmethod
-    def get_indexer_client(config: AlgoClientNetworkConfig | None = None) -> IndexerClient:
+    def get_indexer_client(config: AlgoClientNetworkConfig) -> IndexerClient:
         """Get an Indexer client from config or environment.
 
         :param config: Optional client configuration
         :return: Indexer client instance
         """
-        config = config or _get_config_from_environment("INDEXER")
         headers = {"X-Indexer-API-Token": config.token}
-        return IndexerClient(indexer_token=config.token, indexer_address=config.server, headers=headers)
+        return IndexerClient(
+            indexer_token=config.token,
+            indexer_address=config.full_url(),
+            headers=headers,
+        )
 
     @staticmethod
     def get_indexer_client_from_environment() -> IndexerClient:
@@ -611,7 +616,7 @@ class ClientManager:
             else {"algod": 4001, "indexer": 8980, "kmd": 4002}[config_or_port]
         )
 
-        return AlgoClientNetworkConfig(server=f"http://localhost:{port}", token="a" * 64)
+        return AlgoClientNetworkConfig(server="http://localhost", token="a" * 64, port=port)
 
     @staticmethod
     def get_algod_config_from_environment() -> AlgoClientNetworkConfig:

algokit_utils/models/amount.py

@@ -13,58 +13,34 @@ class AlgoAmount:
     """Wrapper class to ensure safe, explicit conversion between µAlgo, Algo and numbers.
 
     :example:
-    >>> amount = AlgoAmount(algos=1)
-    >>> amount = AlgoAmount(algo=1)
-    >>> amount = AlgoAmount.from_algos(1)
-    >>> amount = AlgoAmount.from_algo(1)
-    >>> amount = AlgoAmount(micro_algos=1_000_000)
-    >>> amount = AlgoAmount(micro_algo=1_000_000)
-    >>> amount = AlgoAmount.from_micro_algos(1_000_000)
-    >>> amount = AlgoAmount.from_micro_algo(1_000_000)
+        >>> amount = AlgoAmount(algo=1)
+        >>> amount = AlgoAmount.from_algo(1)
+        >>> amount = AlgoAmount(micro_algo=1_000_000)
+        >>> amount = AlgoAmount.from_micro_algo(1_000_000)
     """
 
-    @overload
-    def __init__(self, *, micro_algos: int) -> None: ...
-
     @overload
     def __init__(self, *, micro_algo: int) -> None: ...
 
-    @overload
-    def __init__(self, *, algos: int | Decimal) -> None: ...
-
     @overload
     def __init__(self, *, algo: int | Decimal) -> None: ...
 
     def __init__(
         self,
         *,
-        micro_algos: int | None = None,
         micro_algo: int | None = None,
-        algos: int | Decimal | None = None,
         algo: int | Decimal | None = None,
     ):
-        if micro_algos is None and micro_algo is None and algos is None and algo is None:
+        if micro_algo is None and algo is None:
             raise ValueError("No amount provided")
 
-        if micro_algos is not None:
-            self.amount_in_micro_algo = int(micro_algos)
-        elif micro_algo is not None:
+        if micro_algo is not None:
             self.amount_in_micro_algo = int(micro_algo)
-        elif algos is not None:
-            self.amount_in_micro_algo = int(algos * algosdk.constants.MICROALGOS_TO_ALGOS_RATIO)
         elif algo is not None:
             self.amount_in_micro_algo = int(algo * algosdk.constants.MICROALGOS_TO_ALGOS_RATIO)
         else:
             raise ValueError("Invalid amount provided")
 
-    @property
-    def micro_algos(self) -> int:
-        """Return the amount as a number in µAlgo.
-
-        :returns: The amount in µAlgo.
-        """
-        return self.amount_in_micro_algo
-
     @property
     def micro_algo(self) -> int:
         """Return the amount as a number in µAlgo.
@@ -73,14 +49,6 @@ class AlgoAmount:
         """
         return self.amount_in_micro_algo
 
-    @property
-    def algos(self) -> Decimal:
-        """Return the amount as a number in Algo.
-
-        :returns: The amount in Algo.
-        """
-        return algosdk.util.microalgos_to_algos(self.amount_in_micro_algo)  # type: ignore[no-any-return]
-
     @property
     def algo(self) -> Decimal:
         """Return the amount as a number in Algo.
@@ -89,18 +57,6 @@ class AlgoAmount:
         """
         return algosdk.util.microalgos_to_algos(self.amount_in_micro_algo)  # type: ignore[no-any-return]
 
-    @staticmethod
-    def from_algos(amount: int | Decimal) -> AlgoAmount:
-        """Create an AlgoAmount object representing the given number of Algo.
-
-        :param amount: The amount in Algo.
-        :returns: An AlgoAmount instance.
-
-        :example:
-        >>> amount = AlgoAmount.from_algos(1)
-        """
-        return AlgoAmount(algos=amount)
-
     @staticmethod
     def from_algo(amount: int | Decimal) -> AlgoAmount:
         """Create an AlgoAmount object representing the given number of Algo.
@@ -109,22 +65,10 @@ class AlgoAmount:
         :returns: An AlgoAmount instance.
 
         :example:
-        >>> amount = AlgoAmount.from_algo(1)
+            >>> amount = AlgoAmount.from_algo(1)
         """
         return AlgoAmount(algo=amount)
 
-    @staticmethod
-    def from_micro_algos(amount: int) -> AlgoAmount:
-        """Create an AlgoAmount object representing the given number of µAlgo.
-
-        :param amount: The amount in µAlgo.
-        :returns: An AlgoAmount instance.
-
-        :example:
-        >>> amount = AlgoAmount.from_micro_algos(1_000_000)
-        """
-        return AlgoAmount(micro_algos=amount)
-
     @staticmethod
     def from_micro_algo(amount: int) -> AlgoAmount:
         """Create an AlgoAmount object representing the given number of µAlgo.
@@ -133,7 +77,7 @@ class AlgoAmount:
         :returns: An AlgoAmount instance.
 
         :example:
-        >>> amount = AlgoAmount.from_micro_algo(1_000_000)
+            >>> amount = AlgoAmount.from_micro_algo(1_000_000)
         """
         return AlgoAmount(micro_algo=amount)
 
@@ -141,21 +85,21 @@ class AlgoAmount:
         return f"{self.micro_algo:,} µALGO"
 
     def __int__(self) -> int:
-        return self.micro_algos
+        return self.micro_algo
 
     def __add__(self, other: AlgoAmount) -> AlgoAmount:
         if isinstance(other, AlgoAmount):
-            total_micro_algos = self.micro_algos + other.micro_algos
+            total_micro_algos = self.micro_algo + other.micro_algo
         else:
             raise TypeError(f"Unsupported operand type(s) for +: 'AlgoAmount' and '{type(other).__name__}'")
-        return AlgoAmount.from_micro_algos(total_micro_algos)
+        return AlgoAmount.from_micro_algo(total_micro_algos)
 
     def __radd__(self, other: AlgoAmount) -> AlgoAmount:
         return self.__add__(other)
 
     def __iadd__(self, other: AlgoAmount) -> Self:
         if isinstance(other, AlgoAmount):
-            self.amount_in_micro_algo += other.micro_algos
+            self.amount_in_micro_algo += other.micro_algo
         else:
             raise TypeError(f"Unsupported operand type(s) for +: 'AlgoAmount' and '{type(other).__name__}'")
         return self
@@ -204,42 +148,42 @@ class AlgoAmount:
 
     def __sub__(self, other: AlgoAmount) -> AlgoAmount:
         if isinstance(other, AlgoAmount):
-            total_micro_algos = self.micro_algos - other.micro_algos
+            total_micro_algos = self.micro_algo - other.micro_algo
         else:
             raise TypeError(f"Unsupported operand type(s) for -: 'AlgoAmount' and '{type(other).__name__}'")
-        return AlgoAmount.from_micro_algos(total_micro_algos)
+        return AlgoAmount.from_micro_algo(total_micro_algos)
 
     def __rsub__(self, other: int) -> AlgoAmount:
         if isinstance(other, (int)):
-            total_micro_algos = int(other) - self.micro_algos
-            return AlgoAmount.from_micro_algos(total_micro_algos)
+            total_micro_algos = int(other) - self.micro_algo
+            return AlgoAmount.from_micro_algo(total_micro_algos)
         raise TypeError(f"Unsupported operand type(s) for -: '{type(other).__name__}' and 'AlgoAmount'")
 
     def __isub__(self, other: AlgoAmount) -> Self:
         if isinstance(other, AlgoAmount):
-            self.amount_in_micro_algo -= other.micro_algos
+            self.amount_in_micro_algo -= other.micro_algo
         else:
             raise TypeError(f"Unsupported operand type(s) for -: 'AlgoAmount' and '{type(other).__name__}'")
         return self
 
 
 # Helper functions
-def algo(algos: int) -> AlgoAmount:
+def algo(algo: int) -> AlgoAmount:
     """Create an AlgoAmount object representing the given number of Algo.
 
-    :param algos: The number of Algo to create an AlgoAmount object for.
+    :param algo: The number of Algo to create an AlgoAmount object for.
     :return: An AlgoAmount object representing the given number of Algo.
     """
-    return AlgoAmount.from_algos(algos)
+    return AlgoAmount.from_algo(algo)
 
 
-def micro_algo(microalgos: int) -> AlgoAmount:
+def micro_algo(micro_algo: int) -> AlgoAmount:
     """Create an AlgoAmount object representing the given number of µAlgo.
 
-    :param microalgos: The number of µAlgo to create an AlgoAmount object for.
+    :param micro_algo: The number of µAlgo to create an AlgoAmount object for.
     :return: An AlgoAmount object representing the given number of µAlgo.
     """
-    return AlgoAmount.from_micro_algos(microalgos)
+    return AlgoAmount.from_micro_algo(micro_algo)
 
 
 ALGORAND_MIN_TX_FEE = micro_algo(1_000)
@@ -252,5 +196,5 @@ def transaction_fees(number_of_transactions: int) -> AlgoAmount:
     :return: The total transaction fees.
     """
 
-    total_micro_algos = number_of_transactions * ALGORAND_MIN_TX_FEE.micro_algos
-    return micro_algo(total_micro_algos)
+    total_micro_algos = number_of_transactions * ALGORAND_MIN_TX_FEE.micro_algo
+    return AlgoAmount.from_micro_algo(total_micro_algos)

algokit_utils/models/network.py

@@ -12,11 +12,15 @@ class AlgoClientNetworkConfig:
     {py:class}`algosdk.v2client.indexer.IndexerClient`"""
 
     server: str
-    """URL for the service e.g. `http://localhost:4001` or `https://testnet-api.algonode.cloud`"""
+    """URL for the service e.g. `http://localhost` or `https://testnet-api.algonode.cloud`"""
     token: str | None = None
-    """API Token to authenticate with the service"""
+    """API Token to authenticate with the service e.g '4001' or '8980'"""
     port: str | int | None = None
 
+    def full_url(self) -> str:
+        """Returns the full URL for the service"""
+        return f"{self.server.rstrip('/')}{f':{self.port}' if self.port else ''}"
+
 
 @dataclasses.dataclass
 class AlgoClientConfigs:

algokit_utils/transactions/transaction_composer.py

@@ -68,6 +68,8 @@ __all__ = [
     "TransactionComposer",
     "TransactionComposerBuildResult",
     "TxnParams",
+    "populate_app_call_resources",
+    "prepare_group_for_sending",
     "send_atomic_transaction_composer",
 ]
 
@@ -107,7 +109,7 @@ class PaymentParams(_CommonTxnParams):
     :ivar receiver: The account that will receive the ALGO
     :ivar amount: Amount to send
     :ivar close_remainder_to: If given, close the sender account and send the remaining balance to this address,
-    defaults to None
+        defaults to None
     """
 
     receiver: str
@@ -299,9 +301,9 @@ class AppCreateParams(_CommonTxnParams):
     """Parameters for creating an application.
 
     :ivar approval_program: The program to execute for all OnCompletes other than ClearState as raw teal (string)
-    or compiled teal (bytes)
+        or compiled teal (bytes)
     :ivar clear_state_program: The program to execute for ClearState OnComplete as raw teal (string)
-    or compiled teal (bytes)
+        or compiled teal (bytes)
     :ivar schema: The state schema for the app. This is immutable, defaults to None
     :ivar on_complete: The OnComplete action (cannot be ClearState), defaults to None
     :ivar args: Application arguments, defaults to None
@@ -330,9 +332,9 @@ class AppUpdateParams(_CommonTxnParams):
 
     :ivar app_id: ID of the application
     :ivar approval_program: The program to execute for all OnCompletes other than ClearState as raw teal (string)
-    or compiled teal (bytes)
+        or compiled teal (bytes)
     :ivar clear_state_program: The program to execute for ClearState OnComplete as raw teal (string)
-    or compiled teal (bytes)
+        or compiled teal (bytes)
     :ivar args: Application arguments, defaults to None
     :ivar account_references: Account references, defaults to None
     :ivar app_references: App references, defaults to None
@@ -417,7 +419,7 @@ class AppCallMethodCallParams(_BaseAppMethodCall):
     :ivar app_id: ID of the application
     :ivar method: The ABI method to call
     :ivar args: Arguments to the ABI method, either an ABI value, transaction with explicit signer,
-    transaction, another method call, or None
+        transaction, another method call, or None
     :ivar on_complete: The OnComplete action (cannot be UpdateApplication or ClearState), defaults to None
     """
 
@@ -673,7 +675,7 @@ def _get_group_execution_info(  # noqa: C901, PLR0912
             if not suggested_params:
                 raise ValueError("suggested_params required when cover_app_call_inner_transaction_fees enabled")
 
-            max_fee = max_fees.get(i).micro_algos if max_fees and i in max_fees else None  # type: ignore[union-attr]
+            max_fee = max_fees.get(i).micro_algo if max_fees and i in max_fees else None  # type: ignore[union-attr]
             if max_fee is None:
                 app_call_indexes_without_max_fees.append(i)
             else:
@@ -843,7 +845,7 @@ def prepare_group_for_sending(  # noqa: C901, PLR0912, PLR0915
             if not txn_info:
                 continue
             txn = group[i].txn
-            max_fee = max_fees.get(i).micro_algos if max_fees and i in max_fees else None  # type: ignore[union-attr]
+            max_fee = max_fees.get(i).micro_algo if max_fees and i in max_fees else None  # type: ignore[union-attr]
             immutable_fee = max_fee is not None and max_fee == txn.fee
             priority_multiplier = (
                 1000
@@ -1096,7 +1098,7 @@ def prepare_group_for_sending(  # noqa: C901, PLR0912, PLR0915
                 )
 
             transaction_fee = cur_txn.fee + additional_fee
-            max_fee = max_fees.get(i).micro_algos if max_fees and i in max_fees else None  # type: ignore[union-attr]
+            max_fee = max_fees.get(i).micro_algo if max_fees and i in max_fees else None  # type: ignore[union-attr]
 
             if max_fee is None or transaction_fee > max_fee:
                 raise ValueError(
@@ -1324,7 +1326,7 @@ class TransactionComposer:
     :param algod: An instance of AlgodClient used to get suggested params and send transactions
     :param get_signer: A function that takes an address and returns a TransactionSigner for that address
     :param get_suggested_params: Optional function to get suggested transaction parameters,
-    defaults to using algod.suggested_params()
+        defaults to using algod.suggested_params()
     :param default_validity_window: Optional default validity window for transactions in rounds, defaults to 10
     :param app_manager: Optional AppManager instance for compiling TEAL programs, defaults to None
     """
@@ -1600,6 +1602,8 @@ class TransactionComposer:
                     signers[idx] = ts.signer
                 if isinstance(ts, TransactionWithSignerAndContext) and ts.context.abi_method:
                     method_calls[idx] = ts.context.abi_method
+                    if ts.context.max_fee:
+                        self._txn_max_fees[idx] = ts.context.max_fee
                 idx += 1
 
         return BuiltTransactions(transactions=transactions, method_calls=method_calls, signers=signers)
@@ -1681,7 +1685,7 @@ class TransactionComposer:
 
         :param allow_more_logs: Whether to allow more logs than the standard limit
         :param allow_empty_signatures: Whether to allow transactions with empty signatures
-        :param allow_unnamed_resources: Whether to allow unnamed resources
+        :param allow_unnamed_resources: Whether to allow unnamed resources.
         :param extra_opcode_budget: Additional opcode budget to allocate
         :param exec_trace_config: Configuration for execution tracing
         :param simulation_round: Round number to simulate at
@@ -1839,7 +1843,7 @@ class TransactionComposer:
                 txn_params["sp"].last = txn_params["sp"].first + window
 
         if params.static_fee is not None and txn_params["sp"]:
-            txn_params["sp"].fee = params.static_fee.micro_algos
+            txn_params["sp"].fee = params.static_fee.micro_algo
             txn_params["sp"].flat_fee = True
 
         if isinstance(txn_params.get("method"), Arc56Method):
@@ -1848,9 +1852,9 @@ class TransactionComposer:
         txn = build_txn(txn_params)
 
         if params.extra_fee:
-            txn.fee += params.extra_fee.micro_algos
+            txn.fee += params.extra_fee.micro_algo
 
-        if params.max_fee and txn.fee > params.max_fee.micro_algos:
+        if params.max_fee and txn.fee > params.max_fee.micro_algo:
             raise ValueError(f"Transaction fee {txn.fee} is greater than max_fee {params.max_fee}")
         use_max_fee = params.max_fee and params.max_fee.micro_algo > (
             params.static_fee.micro_algo if params.static_fee else 0
@@ -2037,7 +2041,7 @@ class TransactionComposer:
             "sender": params.sender,
             "sp": suggested_params,
             "receiver": params.receiver,
-            "amt": params.amount.micro_algos,
+            "amt": params.amount.micro_algo,
             "close_remainder_to": params.close_remainder_to,
         }
 

{algokit_utils-3.0.0b4.dist-info → algokit_utils-3.0.0b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: algokit-utils
-Version: 3.0.0b4
+Version: 3.0.0b5
 Summary: Utilities for Algorand development for use by AlgoKit
 License: MIT
 Author: Algorand Foundation

{algokit_utils-3.0.0b4.dist-info → algokit_utils-3.0.0b5.dist-info}/RECORD

@@ -3,7 +3,7 @@ algokit_utils/_debugging.py,sha256=nAiC10WXiZsvc0RPWOrMLpjJQZT_ItgcMl7D9Z4DfYc,1
 algokit_utils/_legacy_v2/__init__.py,sha256=WcRE30axWjGnBB09bJCeTw9NT-2_jDN_CVJITFcIDc8,4689
 algokit_utils/_legacy_v2/_ensure_funded.py,sha256=tw4ZEcqsKBHbSCH9gPz3V2onGaj1kyv6BM9V59fLgCU,6931
 algokit_utils/_legacy_v2/_transfer.py,sha256=FRut71CU8kDn4-FqMepwZGjFPhPtQg5Wv5_kdtVqK-8,6256
-algokit_utils/_legacy_v2/account.py,sha256=yP3t7qB-fAXfLf8G5buYgsdknwrdigzrWsTu08XJWuE,8224
+algokit_utils/_legacy_v2/account.py,sha256=_4pxTKO6y9XK4CkUb1M9Du_XVXKeU1MWXHx54KPVbMk,8240
 algokit_utils/_legacy_v2/application_client.py,sha256=ScUalY2h2Wj_TAPYdxuucAmdwRwvO-xZ0yOMXDb9OgE,59536
 algokit_utils/_legacy_v2/application_specification.py,sha256=wp2Y9ou2_F-bSFbDnm6AEhFexybmD7-fAT0CuWtO26g,521
 algokit_utils/_legacy_v2/asset.py,sha256=b4GEzsPuHAbb330ZjoyY3lol0SisQGwJiOpnXvuXvJI,7594
@@ -14,14 +14,14 @@ algokit_utils/_legacy_v2/models.py,sha256=hH7aO50E4po4EgxXI9zdX5HTthn1HLfSLvkuPf
 algokit_utils/_legacy_v2/network_clients.py,sha256=5nqC-47hreWvMxR-PQWs_QP44wJDAGhtS1MQv8JQ82o,5660
 algokit_utils/account.py,sha256=gyGrBSoafUh8WV677IzYGkYoxtzzElsgxGMp4SgA4pk,410
 algokit_utils/accounts/__init__.py,sha256=_LyY0se6TaQOes7vAcmbpt6pmG4VKlzfTt37-IjwimA,138
-algokit_utils/accounts/account_manager.py,sha256=pQjfdDeoi5694QYD-EmvlVpuSvIYdFH_e0LKXkcwzRA,39369
-algokit_utils/accounts/kmd_account_manager.py,sha256=7HF2eKYULu6TAXSSXrSGZG7i6VuIEMyf6Ppmo5hE3EI,6342
+algokit_utils/accounts/account_manager.py,sha256=zr8NV6k9L8xESzsmbFK06T-DOmVEvHWcoHgIIX5SDcQ,39763
+algokit_utils/accounts/kmd_account_manager.py,sha256=0flsU5T11JciyL0YvOKDHPVSm-ghV0RjJAbtm8JwrhU,6476
 algokit_utils/algorand.py,sha256=Gtx3vspZmSxUrNWmh09NFQB24G4v4CEogYuRX_9o5Xw,10554
 algokit_utils/application_client.py,sha256=5UIxXIBjukjRyjZPCeXmaNlAftbb3TziV7EfBolW79k,337
 algokit_utils/application_specification.py,sha256=-ZM13Qv-AcLmwudJCq8xGPoWLvAvKBICgAdHeFozKbY,1416
 algokit_utils/applications/__init__.py,sha256=NGjhpBeExsQZOAYCT2QUFag1xuKoFiX-Ux5SR2GNzd8,452
 algokit_utils/applications/abi.py,sha256=ZwiLuFXx2EwWJ_cOEvNWCzt5onoasm-QmQPv9N7d49g,10087
-algokit_utils/applications/app_client.py,sha256=xHpcZhp6l1PO6OeY009rJ-T3rOyRAS7xrA3evAKI1Jk,83432
+algokit_utils/applications/app_client.py,sha256=oAwe9_6-ETWJIdXNScDvUiVYN8JNP4kplSnr3qCQPVY,84979
 algokit_utils/applications/app_deployer.py,sha256=RrSmIsbN84z0lNtGD8JP2FwkDmsAD_HvF8b4kHnCSmo,23099
 algokit_utils/applications/app_factory.py,sha256=wljyXuXWaMc3KJkDeACJ5XVEfIsVxeSXqdGTJ9p3tJQ,33425
 algokit_utils/applications/app_manager.py,sha256=EA1uRtmvPVAdKi1I5HSCpHjIDgLN7eZcEPT0Cj3C7fU,17661
@@ -31,14 +31,14 @@ algokit_utils/applications/app_spec/arc56.py,sha256=8GyQ_gDBSkHLzTL35D1r7dce5owh
 algokit_utils/applications/enums.py,sha256=1MUBrPW9v0-OZk6jsa5rqSEEpC-z-6QAQIs9G7pLn1I,1257
 algokit_utils/asset.py,sha256=ZnNo_MsDGPb8UTPxi7cmIZpbrT0x0xZjblHP01pDAC0,874
 algokit_utils/assets/__init__.py,sha256=6igogt0eo0TEae6-rO9qPsmlrKkbnkq3aV8wtePX3yk,63
-algokit_utils/assets/asset_manager.py,sha256=S4-ob-JO31aCq3N9tqI2JREtq2R7eJ8F6WTXbQczvg4,14132
+algokit_utils/assets/asset_manager.py,sha256=0vs02dbXarAkVxehM4XJp_AHveZCujIPfnQVXiwhZiw,14152
 algokit_utils/beta/_utils.py,sha256=eGgrSH5dA7Lhe7Z_9rudU7O6azZHMH0U7A3in4GpFOg,1839
 algokit_utils/beta/account_manager.py,sha256=xDFvsMSha0Ki42BGvKvfScQWT_W9y4GeP_RWXjc3vnE,213
 algokit_utils/beta/algorand_client.py,sha256=xDFvsMSha0Ki42BGvKvfScQWT_W9y4GeP_RWXjc3vnE,213
 algokit_utils/beta/client_manager.py,sha256=xDFvsMSha0Ki42BGvKvfScQWT_W9y4GeP_RWXjc3vnE,213
 algokit_utils/beta/composer.py,sha256=xDFvsMSha0Ki42BGvKvfScQWT_W9y4GeP_RWXjc3vnE,213
 algokit_utils/clients/__init__.py,sha256=qUuKBvfLnw4z6ZU9x7mc-mLjfnnXC9UcvtoeU33ZLJ8,136
-algokit_utils/clients/client_manager.py,sha256=DzJMf_jdQoZYNcy0sK34Uv-IenqJmfAupkqzo_Asp-A,25683
+algokit_utils/clients/client_manager.py,sha256=Yl5k7LwlUaoHh76tNK1UxFl8xoFdaTejrhrr488E0Ww,25559
 algokit_utils/clients/dispenser_api_client.py,sha256=lx6II3beCt7YiKO2TrW6UbsRVirf3NoWMJi8HD_W5nI,6045
 algokit_utils/common.py,sha256=5wl83vWw91RYdEC4hTTufqaptKiFtgjKLIyONDmRSH0,300
 algokit_utils/config.py,sha256=Fd466a33pyqmblKn3YUEoSqMSGbKDmZeaS5Uu7_CNHw,7029
@@ -49,9 +49,9 @@ algokit_utils/errors/logic_error.py,sha256=uxqUOU9-D1R5TrKturCbmmWRVlB024Ca4CfVi
 algokit_utils/logic_error.py,sha256=3duw-l6tBr-DeapO0e0tYHoa9rOxP-QZZ6QWmN8L9tc,305
 algokit_utils/models/__init__.py,sha256=0aB_c5pnkqKl1Z0hkxM9qbKn2qVdizZE2DvziN9ObqM,465
 algokit_utils/models/account.py,sha256=TdeKjhYkppD8g0DYRGbnCsi8zfPz3zU74DaZte_CYJw,6014
-algokit_utils/models/amount.py,sha256=2Eb5W9IduM4hqvWz0bpD8-8htKhhmUonaLCuz9c2_1w,9411
+algokit_utils/models/amount.py,sha256=PcjzqRY5ThcUuSYHk1yeYgUooos1j2-54hBIJJcipd4,7567
 algokit_utils/models/application.py,sha256=lM2_g5kZ18k_zyVzcbGvkvqHzksfb2sgRqowJ3pvUgo,1288
-algokit_utils/models/network.py,sha256=Qe631nHpLgjtGcwqWTc6D4Gk_5Fc_dutxD-bCTsb-xw,723
+algokit_utils/models/network.py,sha256=3QNcZ9jVmckv3CCxrD2Y1jiwBdBGdaaziiRgOpsqhwI,904
 algokit_utils/models/simulate.py,sha256=F9OSEfA9QGFGe5po24h8IGLor5z1ogu5Cwm3l6cHnAs,236
 algokit_utils/models/state.py,sha256=N6jsjZiZsz-Rn1ZDnBRvVv1En-lUrh97JuaaDRZtCkg,1478
 algokit_utils/models/transaction.py,sha256=Am0-rmfiANVq9_Zbd1zMTtaV91ZcPqtEfpp2ScQ2Ji8,3052
@@ -61,10 +61,10 @@ algokit_utils/protocols/account.py,sha256=CowaVY7ErBP84TWBHNvBjkZy18whPb8HIlMZtJ
 algokit_utils/protocols/typed_clients.py,sha256=UrQrHbN2SvS8pEFJ8JQodvouoWeBrQOQGZGyBQx1KLM,3322
 algokit_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 algokit_utils/transactions/__init__.py,sha256=7fYF3m6DyOGzbV36MT5svo0wSkj9AIz496kWgIWSAlk,225
-algokit_utils/transactions/transaction_composer.py,sha256=yGLFgJk51BKgnwbGYmmuDIE7WPpZZmHqVAVZ7IWcRDQ,94794
+algokit_utils/transactions/transaction_composer.py,sha256=AZ4xVHH1IFSKSoxdHpvGVfa2v-e9MkZGiXilCHnjfqE,94996
 algokit_utils/transactions/transaction_creator.py,sha256=A1YHeGC2EkR2V0HPYJiXVOAEIrfjBW2KVyYgi3exm4E,6167
 algokit_utils/transactions/transaction_sender.py,sha256=uQmHElJgUIxLXfdklMNoabjQQzUku8CFP82wwhfr44E,22769
-algokit_utils-3.0.0b4.dist-info/LICENSE,sha256=J5i7U1Q9Q2c7saUzlvFRmrCCFhQyXb5Juz_LO5omNUw,1076
-algokit_utils-3.0.0b4.dist-info/METADATA,sha256=-QVF-0xUq7DMn6ZLnL4uBA5M0pnI5yh2UrjuDOBFCOk,2416
-algokit_utils-3.0.0b4.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-algokit_utils-3.0.0b4.dist-info/RECORD,,
+algokit_utils-3.0.0b5.dist-info/LICENSE,sha256=J5i7U1Q9Q2c7saUzlvFRmrCCFhQyXb5Juz_LO5omNUw,1076
+algokit_utils-3.0.0b5.dist-info/METADATA,sha256=agxt079grOlLMzeM0hMFI9g-yl8PfBbVqKUVCMAF1M8,2416
+algokit_utils-3.0.0b5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+algokit_utils-3.0.0b5.dist-info/RECORD,,