algokit-utils 2.2.2b5__py3-none-any.whl → 2.3.0__py3-none-any.whl

algokit_utils/_transfer.py

@@ -86,7 +86,7 @@ def transfer(client: "AlgodClient", parameters: TransferParameters) -> PaymentTx
     params = parameters
     params.suggested_params = parameters.suggested_params or client.suggested_params()
     from_account = params.from_account
-    sender = address_from_private_key(from_account.private_key)  # type: ignore[no-untyped-call]
+    sender = _get_address(from_account)
     transaction = PaymentTxn(
         sender=sender,
         receiver=params.to_address,
@@ -105,7 +105,7 @@ def transfer_asset(client: "AlgodClient", parameters: TransferAssetParameters) -
 
     params = parameters
     params.suggested_params = parameters.suggested_params or client.suggested_params()
-    sender = address_from_private_key(parameters.from_account.private_key)  # type: ignore[no-untyped-call]
+    sender = _get_address(parameters.from_account)
     suggested_params = parameters.suggested_params or client.suggested_params()
     xfer_txn = AssetTransferTxn(
         sp=suggested_params,
@@ -139,9 +139,14 @@ def _send_transaction(
     client.send_transaction(signed_transaction)
 
     txid = transaction.get_txid()  # type: ignore[no-untyped-call]
-    logger.debug(
-        f"Sent transaction {txid} type={transaction.type} from "
-        f"{address_from_private_key(parameters.from_account.private_key)}"  # type: ignore[no-untyped-call]
-    )
+    logger.debug(f"Sent transaction {txid} type={transaction.type} from {_get_address(parameters.from_account)}")
 
     return transaction
+
+
+def _get_address(account: Account | AccountTransactionSigner) -> str:
+    if type(account) is Account:
+        return account.address
+    else:
+        address = address_from_private_key(account.private_key)  # type: ignore[no-untyped-call]
+        return str(address)

algokit_utils/application_client.py

@@ -1,6 +1,5 @@
 import base64
 import copy
-import dataclasses
 import json
 import logging
 import re
@@ -59,6 +58,7 @@ if typing.TYPE_CHECKING:
     from algosdk.v2client.algod import AlgodClient
     from algosdk.v2client.indexer import IndexerClient
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -375,7 +375,7 @@ class ApplicationClient:
     ) -> None:
         """Adds a signed transaction with application id == 0 and the schema and source of client's app_spec to atc"""
         approval_program, clear_program = self._check_is_compiled()
-        transaction_parameters = _convert_transaction_parameters(CreateCallParameters, transaction_parameters)
+        transaction_parameters = _convert_transaction_parameters(transaction_parameters)
 
         extra_pages = transaction_parameters.extra_pages or num_extra_program_pages(
             approval_program.raw_binary, clear_program.raw_binary
@@ -388,7 +388,7 @@ class ApplicationClient:
             abi_args=abi_kwargs,
             on_complete=transaction_parameters.on_complete or transaction.OnComplete.NoOpOC,
             call_config=au_spec.CallConfig.CREATE,
-            parameters=_convert_transaction_parameters(TransactionParameters, transaction_parameters),
+            parameters=transaction_parameters,
             approval_program=approval_program.raw_binary,
             clear_program=clear_program.raw_binary,
             global_schema=self.app_spec.global_state_schema,
@@ -567,12 +567,12 @@ class ApplicationClient:
         **abi_kwargs: ABIArgType,
     ) -> None:
         """Adds a signed transaction with specified parameters to atc"""
-        _parameters = _convert_transaction_parameters(OnCompleteCallParameters, transaction_parameters)
+        _parameters = _convert_transaction_parameters(transaction_parameters)
         self.add_method_call(
             atc,
             abi_method=call_abi_method,
             abi_args=abi_kwargs,
-            parameters=_convert_transaction_parameters(TransactionParameters, transaction_parameters),
+            parameters=_parameters,
             on_complete=_parameters.on_complete or transaction.OnComplete.NoOpOC,
         )
 
@@ -607,7 +607,7 @@ class ApplicationClient:
     ) -> TransactionResponse | ABITransactionResponse:
         """Submits a signed transaction with specified parameters"""
         atc = AtomicTransactionComposer()
-        _parameters = _convert_transaction_parameters(OnCompleteCallParameters, transaction_parameters)
+        _parameters = _convert_transaction_parameters(transaction_parameters)
         self.compose_call(
             atc,
             call_abi_method=call_abi_method,
@@ -1003,7 +1003,7 @@ class ApplicationClient:
         if app_id is None:
             self._load_reference_and_check_app_id()
             app_id = self.app_id
-        parameters = _convert_transaction_parameters(TransactionParameters, parameters)
+        parameters = _convert_transaction_parameters(parameters)
         method = self._resolve_method(abi_method, abi_args, on_complete, call_config)
         sp = parameters.suggested_params or self.suggested_params or self.algod_client.suggested_params()
         signer, sender = self.resolve_signer_sender(parameters.signer, parameters.sender)
@@ -1317,18 +1317,11 @@ def _create_simulate_traces(simulate: SimulateAtomicTransactionResponse) -> list
     return traces
 
 
-_TParams = typing.TypeVar("_TParams", TransactionParameters, OnCompleteCallParameters, CreateCallParameters)
-
-
 def _convert_transaction_parameters(
-    cls: type[_TParams],
-    args: object | None,
-) -> _TParams:
-    if args is None:
-        return cls()
-    args_dict = args.__dict__ if not isinstance(args, dict) else (args or {})
-    _args = {f.name: args_dict[f.name] for f in dataclasses.fields(cls) if f.name in args_dict}
-    return cls(**_args)
+    args: TransactionParameters | TransactionParametersDict | None,
+) -> CreateCallParameters:
+    _args = args.__dict__ if isinstance(args, TransactionParameters) else (args or {})
+    return CreateCallParameters(**_args)
 
 
 def get_sender_from_signer(signer: TransactionSigner | None) -> str | None:

algokit_utils/beta/account_manager.py

@@ -0,0 +1,200 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from algokit_utils.account import get_dispenser_account, get_kmd_wallet_account, get_localnet_default_account
+from algosdk.account import generate_account
+from algosdk.atomic_transaction_composer import AccountTransactionSigner, TransactionSigner
+from typing_extensions import Self
+
+from .client_manager import ClientManager
+
+
+@dataclass
+class AddressAndSigner:
+    address: str
+    signer: TransactionSigner
+
+
+class AccountManager:
+    """Creates and keeps track of addresses and signers"""
+
+    def __init__(self, client_manager: ClientManager):
+        """
+        Create a new account manager.
+
+        :param client_manager: The ClientManager client to use for algod and kmd clients
+        """
+        self._client_manager = client_manager
+        self._accounts = dict[str, TransactionSigner]()
+        self._default_signer: TransactionSigner | None = None
+
+    def set_default_signer(self, signer: TransactionSigner) -> Self:
+        """
+        Sets the default signer to use if no other signer is specified.
+
+        :param signer: The signer to use, either a `TransactionSigner` or a `TransactionSignerAccount`
+        :return: The `AccountManager` so method calls can be chained
+        """
+        self._default_signer = signer
+        return self
+
+    def set_signer(self, sender: str, signer: TransactionSigner) -> Self:
+        """
+        Tracks the given account for later signing.
+
+        :param sender: The sender address to use this signer for
+        :param signer: The signer to sign transactions with for the given sender
+        :return: The AccountCreator instance for method chaining
+        """
+        self._accounts[sender] = signer
+        return self
+
+    def get_signer(self, sender: str) -> TransactionSigner:
+        """
+        Returns the `TransactionSigner` for the given sender address.
+
+        If no signer has been registered for that address then the default signer is used if registered.
+
+        :param sender: The sender address
+        :return: The `TransactionSigner` or throws an error if not found
+        """
+        signer = self._accounts.get(sender, None) or self._default_signer
+        if not signer:
+            raise ValueError(f"No signer found for address {sender}")
+        return signer
+
+    def get_information(self, sender: str) -> dict[str, Any]:
+        """
+        Returns the given sender account's current status, balance and spendable amounts.
+
+        Example:
+            address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA"
+            account_info = account.get_information(address)
+
+        `Response data schema details <https://developer.algorand.org/docs/rest-apis/algod/#get-v2accountsaddress>`_
+
+        :param sender: The address of the sender/account to look up
+        :return: The account information
+        """
+        info = self._client_manager.algod.account_info(sender)
+        assert isinstance(info, dict)
+        return info
+
+    def get_asset_information(self, sender: str, asset_id: int) -> dict[str, Any]:
+        info = self._client_manager.algod.account_asset_info(sender, asset_id)
+        assert isinstance(info, dict)
+        return info
+
+    # TODO
+    # def from_mnemonic(self, mnemonic_secret: str, sender: Optional[str] = None) -> AddrAndSigner:
+    #     """
+    #     Tracks and returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
+
+    #     Example:
+    #         account = account.from_mnemonic("mnemonic secret ...")
+    #         rekeyed_account = account.from_mnemonic("mnemonic secret ...", "SENDERADDRESS...")
+
+    #     :param mnemonic_secret: The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,
+    #         never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.
+    #     :param sender: The optional sender address to use this signer for (aka a rekeyed account)
+    #     :return: The account
+    #     """
+    #     account = mnemonic_account(mnemonic_secret)
+    #     return self.signer_account(rekeyed_account(account, sender) if sender else account)
+
+    def from_kmd(
+        self,
+        name: str,
+        predicate: Callable[[dict[str, Any]], bool] | None = None,
+    ) -> AddressAndSigner:
+        """
+        Tracks and returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
+
+        Example (Get default funded account in a LocalNet):
+            default_dispenser_account = account.from_kmd('unencrypted-default-wallet',
+                lambda a: a['status'] != 'Offline' and a['amount'] > 1_000_000_000
+            )
+
+        :param name: The name of the wallet to retrieve an account from
+        :param predicate: An optional filter to use to find the account (otherwise it will return a random account from the wallet)
+        :return: The account
+        """
+        account = get_kmd_wallet_account(
+            name=name, predicate=predicate, client=self._client_manager.algod, kmd_client=self._client_manager.kmd
+        )
+        if not account:
+            raise ValueError(f"Unable to find KMD account {name}{' with predicate' if predicate else ''}")
+
+        self.set_signer(account.address, account.signer)
+        return AddressAndSigner(address=account.address, signer=account.signer)
+
+    # TODO
+    # def multisig(
+    #     self, multisig_params: algosdk.MultisigMetadata, signing_accounts: Union[algosdk.Account, SigningAccount]
+    # ) -> TransactionSignerAccount:
+    #     """
+    #     Tracks and returns an account that supports partial or full multisig signing.
+
+    #     Example:
+    #         account = account.multisig(
+    #             {
+    #                 "version": 1,
+    #                 "threshold": 1,
+    #                 "addrs": ["ADDRESS1...", "ADDRESS2..."]
+    #             },
+    #             account.from_environment('ACCOUNT1')
+    #         )
+
+    #     :param multisig_params: The parameters that define the multisig account
+    #     :param signing_accounts: The signers that are currently present
+    #     :return: A multisig account wrapper
+    #     """
+    #     return self.signer_account(multisig_account(multisig_params, signing_accounts))
+
+    def random(self) -> AddressAndSigner:
+        """
+        Tracks and returns a new, random Algorand account with secret key loaded.
+
+        Example:
+            account = account.random()
+
+        :return: The account
+        """
+        (sk, addr) = generate_account()  # type: ignore[no-untyped-call]
+        signer = AccountTransactionSigner(sk)
+
+        self.set_signer(addr, signer)
+
+        return AddressAndSigner(address=addr, signer=signer)
+
+    def dispenser(self) -> AddressAndSigner:
+        """
+        Returns an account (with private key loaded) that can act as a dispenser.
+
+        Example:
+            account = account.dispenser()
+
+        If running on LocalNet then it will return the default dispenser account automatically,
+        otherwise it will load the account mnemonic stored in os.environ['DISPENSER_MNEMONIC'].
+
+        :return: The account
+        """
+        acct = get_dispenser_account(self._client_manager.algod)
+
+        self.set_signer(acct.address, acct.signer)
+
+        return AddressAndSigner(address=acct.address, signer=acct.signer)
+
+    def localnet_dispenser(self) -> AddressAndSigner:
+        """
+        Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts).
+
+        Example:
+            account = account.localnet_dispenser()
+
+        :return: The account
+        """
+        acct = get_localnet_default_account(self._client_manager.algod)
+        self.set_signer(acct.address, acct.signer)
+        return AddressAndSigner(address=acct.address, signer=acct.signer)

algokit_utils/beta/algorand_client.py

@@ -0,0 +1,319 @@
+import copy
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from algokit_utils.beta.account_manager import AccountManager
+from algokit_utils.beta.client_manager import AlgoSdkClients, ClientManager
+from algokit_utils.beta.composer import (
+    AlgokitComposer,
+    AppCallParams,
+    AssetConfigParams,
+    AssetCreateParams,
+    AssetDestroyParams,
+    AssetFreezeParams,
+    AssetOptInParams,
+    AssetTransferParams,
+    MethodCallParams,
+    OnlineKeyRegParams,
+    PayParams,
+)
+from algokit_utils.network_clients import (
+    AlgoClientConfigs,
+    get_algod_client,
+    get_algonode_config,
+    get_default_localnet_config,
+    get_indexer_client,
+    get_kmd_client,
+)
+from algosdk.atomic_transaction_composer import AtomicTransactionResponse, TransactionSigner
+from algosdk.transaction import SuggestedParams, Transaction, wait_for_confirmation
+from typing_extensions import Self
+
+__all__ = [
+    "AlgorandClient",
+    "AssetCreateParams",
+    "AssetOptInParams",
+    "MethodCallParams",
+    "PayParams",
+    "AssetFreezeParams",
+    "AssetConfigParams",
+    "AssetDestroyParams",
+    "AppCallParams",
+    "OnlineKeyRegParams",
+    "AssetTransferParams",
+]
+
+
+@dataclass
+class AlgorandClientSendMethods:
+    """
+    Methods used to send a transaction to the network and wait for confirmation
+    """
+
+    payment: Callable[[PayParams], dict[str, Any]]
+    asset_create: Callable[[AssetCreateParams], dict[str, Any]]
+    asset_config: Callable[[AssetConfigParams], dict[str, Any]]
+    asset_freeze: Callable[[AssetFreezeParams], dict[str, Any]]
+    asset_destroy: Callable[[AssetDestroyParams], dict[str, Any]]
+    asset_transfer: Callable[[AssetTransferParams], dict[str, Any]]
+    app_call: Callable[[AppCallParams], dict[str, Any]]
+    online_key_reg: Callable[[OnlineKeyRegParams], dict[str, Any]]
+    method_call: Callable[[MethodCallParams], dict[str, Any]]
+    asset_opt_in: Callable[[AssetOptInParams], dict[str, Any]]
+
+
+@dataclass
+class AlgorandClientTransactionMethods:
+    """
+    Methods used to form a transaction without signing or sending to the network
+    """
+
+    payment: Callable[[PayParams], Transaction]
+    asset_create: Callable[[AssetCreateParams], Transaction]
+    asset_config: Callable[[AssetConfigParams], Transaction]
+    asset_freeze: Callable[[AssetFreezeParams], Transaction]
+    asset_destroy: Callable[[AssetDestroyParams], Transaction]
+    asset_transfer: Callable[[AssetTransferParams], Transaction]
+    app_call: Callable[[AppCallParams], Transaction]
+    online_key_reg: Callable[[OnlineKeyRegParams], Transaction]
+    method_call: Callable[[MethodCallParams], list[Transaction]]
+    asset_opt_in: Callable[[AssetOptInParams], Transaction]
+
+
+class AlgorandClient:
+    """A client that brokers easy access to Algorand functionality."""
+
+    def __init__(self, config: AlgoClientConfigs | AlgoSdkClients):
+        self._client_manager: ClientManager = ClientManager(config)
+        self._account_manager: AccountManager = AccountManager(self._client_manager)
+
+        self._cached_suggested_params: SuggestedParams | None = None
+        self._cached_suggested_params_expiry: float | None = None
+        self._cached_suggested_params_timeout: int = 3_000  # three seconds
+
+        self._default_validity_window: int = 10
+
+    def _unwrap_single_send_result(self, results: AtomicTransactionResponse) -> dict[str, Any]:
+        return {
+            "confirmation": wait_for_confirmation(self._client_manager.algod, results.tx_ids[0]),
+            "tx_id": results.tx_ids[0],
+        }
+
+    def set_default_validity_window(self, validity_window: int) -> Self:
+        """
+        Sets the default validity window for transactions.
+
+        :param validity_window: The number of rounds between the first and last valid rounds
+        :return: The `AlgorandClient` so method calls can be chained
+        """
+        self._default_validity_window = validity_window
+        return self
+
+    def set_default_signer(self, signer: TransactionSigner) -> Self:
+        """
+        Sets the default signer to use if no other signer is specified.
+
+        :param signer: The signer to use, either a `TransactionSigner` or a `TransactionSignerAccount`
+        :return: The `AlgorandClient` so method calls can be chained
+        """
+        self._account_manager.set_default_signer(signer)
+        return self
+
+    def set_signer(self, sender: str, signer: TransactionSigner) -> Self:
+        """
+        Tracks the given account for later signing.
+
+        :param sender: The sender address to use this signer for
+        :param signer: The signer to sign transactions with for the given sender
+        :return: The `AlgorandClient` so method calls can be chained
+        """
+        self._account_manager.set_signer(sender, signer)
+        return self
+
+    def set_suggested_params(self, suggested_params: SuggestedParams, until: float | None = None) -> Self:
+        """
+        Sets a cache value to use for suggested params.
+
+        :param suggested_params: The suggested params to use
+        :param until: A timestamp until which to cache, or if not specified then the timeout is used
+        :return: The `AlgorandClient` so method calls can be chained
+        """
+        self._cached_suggested_params = suggested_params
+        self._cached_suggested_params_expiry = until or time.time() + self._cached_suggested_params_timeout
+        return self
+
+    def set_suggested_params_timeout(self, timeout: int) -> Self:
+        """
+        Sets the timeout for caching suggested params.
+
+        :param timeout: The timeout in milliseconds
+        :return: The `AlgorandClient` so method calls can be chained
+        """
+        self._cached_suggested_params_timeout = timeout
+        return self
+
+    def get_suggested_params(self) -> SuggestedParams:
+        """Get suggested params for a transaction (either cached or from algod if the cache is stale or empty)"""
+        if self._cached_suggested_params and (
+            self._cached_suggested_params_expiry is None or self._cached_suggested_params_expiry > time.time()
+        ):
+            return copy.deepcopy(self._cached_suggested_params)
+
+        self._cached_suggested_params = self._client_manager.algod.suggested_params()
+        self._cached_suggested_params_expiry = time.time() + self._cached_suggested_params_timeout
+
+        return copy.deepcopy(self._cached_suggested_params)
+
+    @property
+    def client(self) -> ClientManager:
+        """Get clients, including algosdk clients and app clients."""
+        return self._client_manager
+
+    @property
+    def account(self) -> AccountManager:
+        """Get or create accounts that can sign transactions."""
+        return self._account_manager
+
+    def new_group(self) -> AlgokitComposer:
+        """Start a new `AlgokitComposer` transaction group"""
+        return AlgokitComposer(
+            algod=self.client.algod,
+            get_signer=lambda addr: self.account.get_signer(addr),
+            get_suggested_params=self.get_suggested_params,
+            default_validity_window=self._default_validity_window,
+        )
+
+    @property
+    def send(self) -> AlgorandClientSendMethods:
+        """Methods for sending a transaction and waiting for confirmation"""
+        return AlgorandClientSendMethods(
+            payment=lambda params: self._unwrap_single_send_result(self.new_group().add_payment(params).execute()),
+            asset_create=lambda params: self._unwrap_single_send_result(
+                self.new_group().add_asset_create(params).execute()
+            ),
+            asset_config=lambda params: self._unwrap_single_send_result(
+                self.new_group().add_asset_config(params).execute()
+            ),
+            asset_freeze=lambda params: self._unwrap_single_send_result(
+                self.new_group().add_asset_freeze(params).execute()
+            ),
+            asset_destroy=lambda params: self._unwrap_single_send_result(
+                self.new_group().add_asset_destroy(params).execute()
+            ),
+            asset_transfer=lambda params: self._unwrap_single_send_result(
+                self.new_group().add_asset_transfer(params).execute()
+            ),
+            app_call=lambda params: self._unwrap_single_send_result(self.new_group().add_app_call(params).execute()),
+            online_key_reg=lambda params: self._unwrap_single_send_result(
+                self.new_group().add_online_key_reg(params).execute()
+            ),
+            method_call=lambda params: self._unwrap_single_send_result(
+                self.new_group().add_method_call(params).execute()
+            ),
+            asset_opt_in=lambda params: self._unwrap_single_send_result(
+                self.new_group().add_asset_opt_in(params).execute()
+            ),
+        )
+
+    @property
+    def transactions(self) -> AlgorandClientTransactionMethods:
+        """Methods for building transactions"""
+
+        return AlgorandClientTransactionMethods(
+            payment=lambda params: self.new_group().add_payment(params).build_group()[0].txn,
+            asset_create=lambda params: self.new_group().add_asset_create(params).build_group()[0].txn,
+            asset_config=lambda params: self.new_group().add_asset_config(params).build_group()[0].txn,
+            asset_freeze=lambda params: self.new_group().add_asset_freeze(params).build_group()[0].txn,
+            asset_destroy=lambda params: self.new_group().add_asset_destroy(params).build_group()[0].txn,
+            asset_transfer=lambda params: self.new_group().add_asset_transfer(params).build_group()[0].txn,
+            app_call=lambda params: self.new_group().add_app_call(params).build_group()[0].txn,
+            online_key_reg=lambda params: self.new_group().add_online_key_reg(params).build_group()[0].txn,
+            method_call=lambda params: [txn.txn for txn in self.new_group().add_method_call(params).build_group()],
+            asset_opt_in=lambda params: self.new_group().add_asset_opt_in(params).build_group()[0].txn,
+        )
+
+    @staticmethod
+    def default_local_net() -> "AlgorandClient":
+        """
+        Returns an `AlgorandClient` pointing at default LocalNet ports and API token.
+
+        :return: The `AlgorandClient`
+        """
+        return AlgorandClient(
+            AlgoClientConfigs(
+                algod_config=get_default_localnet_config("algod"),
+                indexer_config=get_default_localnet_config("indexer"),
+                kmd_config=get_default_localnet_config("kmd"),
+            )
+        )
+
+    @staticmethod
+    def test_net() -> "AlgorandClient":
+        """
+        Returns an `AlgorandClient` pointing at TestNet using AlgoNode.
+
+        :return: The `AlgorandClient`
+        """
+        return AlgorandClient(
+            AlgoClientConfigs(
+                algod_config=get_algonode_config("testnet", "algod", ""),
+                indexer_config=get_algonode_config("testnet", "indexer", ""),
+                kmd_config=None,
+            )
+        )
+
+    @staticmethod
+    def main_net() -> "AlgorandClient":
+        """
+        Returns an `AlgorandClient` pointing at MainNet using AlgoNode.
+
+        :return: The `AlgorandClient`
+        """
+        return AlgorandClient(
+            AlgoClientConfigs(
+                algod_config=get_algonode_config("mainnet", "algod", ""),
+                indexer_config=get_algonode_config("mainnet", "indexer", ""),
+                kmd_config=None,
+            )
+        )
+
+    @staticmethod
+    def from_clients(clients: AlgoSdkClients) -> "AlgorandClient":
+        """
+        Returns an `AlgorandClient` pointing to the given client(s).
+
+        :param clients: The clients to use
+        :return: The `AlgorandClient`
+        """
+        return AlgorandClient(clients)
+
+    @staticmethod
+    def from_environment() -> "AlgorandClient":
+        """
+        Returns an `AlgorandClient` loading the configuration from environment variables.
+
+        Retrieve configurations from environment variables when defined or get defaults.
+
+        Expects to be called from a Python environment.
+
+        :return: The `AlgorandClient`
+        """
+        return AlgorandClient(
+            AlgoSdkClients(
+                algod=get_algod_client(),
+                kmd=get_kmd_client(),
+                indexer=get_indexer_client(),
+            )
+        )
+
+    @staticmethod
+    def from_config(config: AlgoClientConfigs) -> "AlgorandClient":
+        """
+        Returns an `AlgorandClient` from the given config.
+
+        :param config: The config to use
+        :return: The `AlgorandClient`
+        """
+        return AlgorandClient(config)