algokit-utils 3.0.0b1__py3-none-any.whl → 3.0.0b3__py3-none-any.whl

algokit_utils/beta/account_manager.py

@@ -1,200 +1,9 @@
-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 algokit_utils.beta._utils import handle_getattr
 
-from .client_manager import ClientManager
 
+def __getattr__(name: str) -> Any:  # noqa: ANN401
+    """Handle deprecated imports of parameter classes"""
 
-@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)
+    handle_getattr(name)

algokit_utils/beta/algorand_client.py

@@ -1,319 +1,9 @@
-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
+from algokit_utils.beta._utils import handle_getattr
 
-__all__ = [
-    "AlgorandClient",
-    "AssetCreateParams",
-    "AssetOptInParams",
-    "MethodCallParams",
-    "PayParams",
-    "AssetFreezeParams",
-    "AssetConfigParams",
-    "AssetDestroyParams",
-    "AppCallParams",
-    "OnlineKeyRegParams",
-    "AssetTransferParams",
-]
 
+def __getattr__(name: str) -> Any:  # noqa: ANN401
+    """Handle deprecated imports of parameter classes"""
 
-@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)
+    handle_getattr(name)

algokit_utils/beta/client_manager.py

@@ -1,78 +1,9 @@
-import algosdk
-from algokit_utils.dispenser_api import TestNetDispenserApiClient
-from algokit_utils.network_clients import AlgoClientConfigs, get_algod_client, get_indexer_client, get_kmd_client
-from algosdk.kmd import KMDClient
-from algosdk.v2client.algod import AlgodClient
-from algosdk.v2client.indexer import IndexerClient
+from typing import Any
 
+from algokit_utils.beta._utils import handle_getattr
 
-class AlgoSdkClients:
-    """
-    Clients from algosdk that interact with the official Algorand APIs.
 
-    Attributes:
-        algod (AlgodClient): Algod client, see https://developer.algorand.org/docs/rest-apis/algod/
-        indexer (Optional[IndexerClient]): Optional indexer client, see https://developer.algorand.org/docs/rest-apis/indexer/
-        kmd (Optional[KMDClient]): Optional KMD client, see https://developer.algorand.org/docs/rest-apis/kmd/
-    """
+def __getattr__(name: str) -> Any:  # noqa: ANN401
+    """Handle deprecated imports of parameter classes"""
 
-    def __init__(
-        self,
-        algod: algosdk.v2client.algod.AlgodClient,
-        indexer: IndexerClient | None = None,
-        kmd: KMDClient | None = None,
-    ):
-        self.algod = algod
-        self.indexer = indexer
-        self.kmd = kmd
-
-
-class ClientManager:
-    """
-    Exposes access to various API clients.
-
-    Args:
-        clients_or_config (Union[AlgoConfig, AlgoSdkClients]): algosdk clients or config for interacting with the official Algorand APIs.
-    """
-
-    def __init__(self, clients_or_configs: AlgoClientConfigs | AlgoSdkClients):
-        if isinstance(clients_or_configs, AlgoSdkClients):
-            _clients = clients_or_configs
-        elif isinstance(clients_or_configs, AlgoClientConfigs):
-            _clients = AlgoSdkClients(
-                algod=get_algod_client(clients_or_configs.algod_config),
-                indexer=get_indexer_client(clients_or_configs.indexer_config)
-                if clients_or_configs.indexer_config
-                else None,
-                kmd=get_kmd_client(clients_or_configs.kmd_config) if clients_or_configs.kmd_config else None,
-            )
-        self._algod = _clients.algod
-        self._indexer = _clients.indexer
-        self._kmd = _clients.kmd
-
-    @property
-    def algod(self) -> AlgodClient:
-        """Returns an algosdk Algod API client."""
-        return self._algod
-
-    @property
-    def indexer(self) -> IndexerClient:
-        """Returns an algosdk Indexer API client or raises an error if it's not been provided."""
-        if not self._indexer:
-            raise ValueError("Attempt to use Indexer client in AlgoKit instance with no Indexer configured")
-        return self._indexer
-
-    @property
-    def kmd(self) -> KMDClient:
-        """Returns an algosdk KMD API client or raises an error if it's not been provided."""
-        if not self._kmd:
-            raise ValueError("Attempt to use Kmd client in AlgoKit instance with no Kmd configured")
-        return self._kmd
-
-    def get_testnet_dispenser(
-        self, auth_token: str | None = None, request_timeout: int | None = None
-    ) -> TestNetDispenserApiClient:
-        if request_timeout:
-            return TestNetDispenserApiClient(auth_token=auth_token, request_timeout=request_timeout)
-
-        return TestNetDispenserApiClient(auth_token=auth_token)
+    handle_getattr(name)