@algorandfoundation/algokit-utils 9.2.0-beta.7 → 10.0.0-alpha.1

package/types/account-manager.mjs

@@ -1,604 +1,610 @@
-import algosdk, { Address } from 'algosdk';
-import { Config } from '../config.mjs';
-import { memoize, calculateFundAmount } from '../util.mjs';
-import { SigningAccount, MultisigAccount, DISPENSER_ACCOUNT } from './account.mjs';
-import { AlgoAmount } from './amount.mjs';
-import { TransactionComposer } from './composer.mjs';
-import { KmdAccountManager } from './kmd-account-manager.mjs';
+import { Address, getAddress, getOptionalAddress } from "../packages/common/src/address.mjs";
+import { generateAddressWithSigners } from "../packages/transact/src/signer.mjs";
+import { MultisigAccount } from "../packages/transact/src/multisig.mjs";
+import { LogicSigAccount } from "../packages/transact/src/logicsig.mjs";
+import { AlgoAmount } from "./amount.mjs";
+import { Config } from "../config.mjs";
+import { calculateFundAmount, memoize } from "../util.mjs";
+import { DISPENSER_ACCOUNT } from "./account.mjs";
+import { TransactionComposer } from "./composer.mjs";
+import { KmdAccountManager } from "./kmd-account-manager.mjs";
+import { seedFromMnemonic } from "../packages/algo25/src/index.mjs";
+import nacl from "tweetnacl";
 
-var LogicSigAccount = algosdk.LogicSigAccount;
-const address = (address) => (typeof address === 'string' ? Address.fromString(address) : address);
+//#region src/types/account-manager.ts
 /**
- * Returns a `TransactionSigner` for the given account that can sign a transaction.
- * This function has memoization, so will return the same transaction signer for a given account.
- * @param account An account that can sign a transaction
- * @returns A transaction signer
- * @example
- * ```typescript
- * const signer = getAccountTransactionSigner(account)
- * ```
- */
-const getAccountTransactionSigner = memoize(function (account) {
-    return 'signer' in account
-        ? account.signer
-        : 'lsig' in account
-            ? algosdk.makeLogicSigAccountTransactionSigner(account)
-            : algosdk.makeBasicAccountTransactionSigner(account);
+* Returns a `TransactionSigner` for the given account that can sign a transaction.
+* This function has memoization, so will return the same transaction signer for a given account.
+* @param account An account that can sign a transaction
+* @returns A transaction signer
+* @example
+* ```typescript
+* const signer = getAccountTransactionSigner(account)
+* ```
+*/
+const getAccountTransactionSigner = memoize(function(account) {
+	return account.signer;
 });
 /** Creates and keeps track of signing accounts that can sign transactions for a sending address. */
-class AccountManager {
-    /**
-     * Create a new account manager.
-     * @param clientManager The ClientManager client to use for algod and kmd clients
-     * @example Create a new account manager
-     * ```typescript
-     * const accountManager = new AccountManager(clientManager)
-     * ```
-     */
-    constructor(clientManager) {
-        this._accounts = {};
-        this._clientManager = clientManager;
-        this._kmdAccountManager = new KmdAccountManager(clientManager);
-    }
-    _getComposer(getSuggestedParams) {
-        return new TransactionComposer({
-            algod: this._clientManager.algod,
-            getSigner: this.getSigner.bind(this),
-            getSuggestedParams: getSuggestedParams ?? (() => this._clientManager.algod.getTransactionParams().do()),
-        });
-    }
-    /**
-     * KMD account manager that allows you to easily get and create accounts using KMD.
-     * @returns The `KmdAccountManager` instance.
-     * @example
-     * ```typescript
-     * const kmdManager = accountManager.kmd;
-     * ```
-     */
-    get kmd() {
-        return this._kmdAccountManager;
-    }
-    /**
-     * Sets the default signer to use if no other signer is specified.
-     *
-     * If this isn't set an a transaction needs signing for a given sender
-     * then an error will be thrown from `getSigner` / `getAccount`.
-     * @param signer The signer to use, either a `TransactionSigner` or a `TransactionSignerAccount`
-     * @example
-     * ```typescript
-     * const signer = accountManager.random() // Can be anything that returns a `algosdk.TransactionSigner` or `TransactionSignerAccount`
-     * accountManager.setDefaultSigner(signer)
-     *
-     * // When signing a transaction, if there is no signer registered for the sender then the default signer will be used
-     * const signer = accountManager.getSigner("SENDERADDRESS")
-     * ```
-     * @returns The `AccountManager` so method calls can be chained
-     */
-    setDefaultSigner(signer) {
-        this._defaultSigner = 'signer' in signer ? signer.signer : signer;
-        return this;
-    }
-    /**
-     * Records the given account (that can sign) against the address of the provided account for later
-     * retrieval and returns a `TransactionSignerAccount` along with the original account in an `account` property.
-     */
-    signerAccount(account) {
-        const signer = getAccountTransactionSigner(account);
-        const acc = {
-            addr: 'addr' in account ? account.addr : account.address(),
-            signer: signer,
-        };
-        this._accounts[acc.addr.toString()] = acc;
-        const addressWithAccount = Address.fromString(acc.addr.toString());
-        addressWithAccount.account = account;
-        addressWithAccount.addr = acc.addr;
-        addressWithAccount.signer = signer;
-        return addressWithAccount;
-    }
-    /**
-     * Tracks the given account for later signing.
-     *
-     * Note: If you are generating accounts via the various methods on `AccountManager`
-     * (like `random`, `fromMnemonic`, `logicsig`, etc.) then they automatically get tracked.
-     * @param account The account to register, which can be a `TransactionSignerAccount` or
-     *  a `algosdk.Account`, `algosdk.LogicSigAccount`, `SigningAccount` or `MultisigAccount`
-     * @example
-     * ```typescript
-     * const accountManager = new AccountManager(clientManager)
-     *  .setSignerFromAccount(algosdk.generateAccount())
-     *  .setSignerFromAccount(new algosdk.LogicSigAccount(program, args))
-     *  .setSignerFromAccount(new SigningAccount(mnemonic, sender))
-     *  .setSignerFromAccount(new MultisigAccount({version: 1, threshold: 1, addrs: ["ADDRESS1...", "ADDRESS2..."]}, [account1, account2]))
-     *  .setSignerFromAccount({addr: "SENDERADDRESS", signer: transactionSigner})
-     * ```
-     * @returns The `AccountManager` instance for method chaining
-     */
-    setSignerFromAccount(account) {
-        this.signerAccount(account);
-        return this;
-    }
-    /**
-     * Tracks the given `algosdk.TransactionSigner` against the given sender address for later signing.
-     * @param sender The sender address to use this signer for
-     * @param signer The `algosdk.TransactionSigner` to sign transactions with for the given sender
-     * @example
-     * ```typescript
-     * const accountManager = new AccountManager(clientManager)
-     *  .setSigner("SENDERADDRESS", transactionSigner)
-     * ```
-     * @returns The `AccountManager` instance for method chaining
-     */
-    setSigner(sender, signer) {
-        this._accounts[address(sender).toString()] = { addr: address(sender), signer };
-        return this;
-    }
-    /**
-     * Takes all registered signers from the given `AccountManager` and adds them to this `AccountManager`.
-     *
-     * This is useful for situations where you have multiple contexts you are building accounts in such as unit tests.
-     * @param anotherAccountManager Another account manager with signers registered
-     * @param overwriteExisting Whether or not to overwrite any signers that have the same sender address with the ones in the other account manager or not (default: true)
-     * @returns The `AccountManager` instance for method chaining
-     * @example
-     * ```typescript
-     * accountManager2.setSigners(accountManager1);
-     * ```
-     */
-    setSigners(anotherAccountManager, overwriteExisting = true) {
-        this._accounts = overwriteExisting
-            ? { ...this._accounts, ...anotherAccountManager._accounts }
-            : { ...anotherAccountManager._accounts, ...this._accounts };
-        return this;
-    }
-    /**
-     * Returns the `TransactionSigner` for the given sender address, ready to sign a transaction for that sender.
-     *
-     * If no signer has been registered for that address then the default signer is used if registered and
-     * if not then an error is thrown.
-     *
-     * @param sender The sender address
-     * @example
-     * ```typescript
-     * const signer = accountManager.getSigner("SENDERADDRESS")
-     * ```
-     * @returns The `TransactionSigner` or throws an error if not found and no default signer is set
-     */
-    getSigner(sender) {
-        const signer = this._accounts[address(sender).toString()]?.signer ?? this._defaultSigner;
-        if (!signer)
-            throw new Error(`No signer found for address ${sender}`);
-        return signer;
-    }
-    /**
-     * Returns the `TransactionSignerAccount` for the given sender address.
-     *
-     * If no signer has been registered for that address then an error is thrown.
-     * @param sender The sender address
-     * @example
-     * ```typescript
-     * const sender = accountManager.random()
-     * // ...
-     * // Returns the `TransactionSignerAccount` for `sender` that has previously been registered
-     * const account = accountManager.getAccount(sender)
-     * ```
-     * @returns The `TransactionSignerAccount` or throws an error if not found
-     */
-    getAccount(sender) {
-        const account = this._accounts[address(sender).toString()];
-        if (!account)
-            throw new Error(`No signer found for address ${sender}`);
-        return account;
-    }
-    /**
-     * Returns the given sender account's current status, balance and spendable amounts.
-     *
-     * [Response data schema details](https://dev.algorand.co/reference/rest-apis/algod/#accountinformation)
-     * @example
-     * ```typescript
-     * const address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA";
-     * const accountInfo = await accountManager.getInformation(address);
-     * ```
-     *
-     * @param sender The account / address to look up
-     * @returns The account information
-     */
-    async getInformation(sender) {
-        const { round, lastHeartbeat = undefined, lastProposed = undefined, address, ...account } = await this._clientManager.algod.accountInformation(sender).do();
-        return {
-            ...account,
-            // None of the Number types can practically overflow 2^53
-            address: Address.fromString(address),
-            balance: AlgoAmount.MicroAlgo(Number(account.amount)),
-            amountWithoutPendingRewards: AlgoAmount.MicroAlgo(Number(account.amountWithoutPendingRewards)),
-            minBalance: AlgoAmount.MicroAlgo(Number(account.minBalance)),
-            pendingRewards: AlgoAmount.MicroAlgo(Number(account.pendingRewards)),
-            rewards: AlgoAmount.MicroAlgo(Number(account.rewards)),
-            validAsOfRound: BigInt(round),
-            totalAppsOptedIn: Number(account.totalAppsOptedIn),
-            totalAssetsOptedIn: Number(account.totalAssetsOptedIn),
-            totalCreatedApps: Number(account.totalCreatedApps),
-            totalCreatedAssets: Number(account.totalCreatedAssets),
-            appsTotalExtraPages: account.appsTotalExtraPages !== undefined ? Number(account.appsTotalExtraPages) : undefined,
-            rewardBase: account.rewardBase !== undefined ? Number(account.rewardBase) : undefined,
-            totalBoxBytes: account.totalBoxBytes !== undefined ? Number(account.totalBoxBytes) : undefined,
-            totalBoxes: account.totalBoxes !== undefined ? Number(account.totalBoxes) : undefined,
-            lastHeartbeatRound: lastHeartbeat !== undefined ? BigInt(lastHeartbeat) : undefined,
-            lastProposedRound: lastProposed !== undefined ? BigInt(lastProposed) : undefined,
-        };
-    }
-    /**
-     * Tracks and returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
-     *
-     * @example
-     * ```typescript
-     * const account = accountManager.fromMnemonic("mnemonic secret ...")
-     * const rekeyedAccount = accountManager.fromMnemonic("mnemonic secret ...", "SENDERADDRESS...")
-     * ```
-     * @param mnemonicSecret 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)
-     * @returns The account
-     */
-    fromMnemonic(mnemonicSecret, sender) {
-        const account = algosdk.mnemonicToSecretKey(mnemonicSecret);
-        return this.signerAccount(new SigningAccount(account, sender));
-    }
-    /**
-     * Tracks and returns an Algorand account that is a rekeyed version of the given account to a new sender.
-     *
-     * @example
-     * ```typescript
-     * const account = accountManager.fromMnemonic("mnemonic secret ...")
-     * const rekeyedAccount = accountManager.rekeyed(account, "SENDERADDRESS...")
-     * ```
-     * @param account The account to use as the signer for this new rekeyed account
-     * @param sender The sender address to use as the new sender
-     * @returns The account
-     */
-    rekeyed(sender, account) {
-        return this.signerAccount({ addr: address(sender), signer: account.signer });
-    }
-    /**
-     * Tracks and returns an Algorand account with private key loaded by convention from environment variables based on the given name identifier.
-     *
-     * Note: This function expects to run in a Node.js environment.
-     *
-     * ## Convention:
-     * * **Non-LocalNet:** will load process.env['\{NAME\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,
-     *  never commit it into source control and ideally load it via a secret storage service rather than the file system.
-     *   If process.env['\{NAME\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)
-     * * **LocalNet:** will load the account from a KMD wallet called \{NAME\} and if that wallet doesn't exist it will create it and fund the account for you
-     *
-     * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).
-     *
-     * @example Default
-     *
-     * If you have a mnemonic secret loaded into `process.env.MY_ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:
-     * ```typescript
-     * const account = await accountManager.fromEnvironment('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 1000 (default) ALGO from the default LocalNet dispenser.
-     * If not running against LocalNet then it will use proces.env.MY_ACCOUNT_MNEMONIC as the private key and (if present) process.env.MY_ACCOUNT_SENDER as the sender address.
-     *
-     * @param name The name identifier of the account
-     * @param fundWith The optional amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account
-     * @returns The account
-     */
-    async fromEnvironment(name, fundWith) {
-        if (!process || !process.env) {
-            throw new Error('Attempt to get account with private key from a non Node.js context; this is not supported!');
-        }
-        const accountMnemonic = process.env[`${name.toUpperCase()}_MNEMONIC`];
-        const sender = process.env[`${name.toUpperCase()}_SENDER`];
-        if (accountMnemonic) {
-            const signer = algosdk.mnemonicToSecretKey(accountMnemonic);
-            return this.signerAccount(new SigningAccount(signer, sender));
-        }
-        if (await this._clientManager.isLocalNet()) {
-            const account = await this._kmdAccountManager.getOrCreateWalletAccount(name, fundWith);
-            return this.signerAccount(account.account);
-        }
-        throw new Error(`Missing environment variable ${name.toUpperCase()}_MNEMONIC when looking for account ${name}`);
-    }
-    /**
-     * Tracks and returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
-     *
-     * @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)
-     * @param sender The optional sender address to use this signer for (aka a rekeyed account)
-     * @example Get default funded account in a LocalNet
-     *
-     * ```typescript
-     * const defaultDispenserAccount = await accountManager.fromKmd('unencrypted-default-wallet',
-     *   a => a.status !== 'Offline' && a.amount > 1_000_000_000
-     * )
-     * ```
-     * @returns The account
-     */
-    async fromKmd(name, 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    predicate, sender) {
-        const account = await this._kmdAccountManager.getWalletAccount(name, predicate, sender);
-        if (!account)
-            throw new Error(`Unable to find KMD account ${name}${predicate ? ' with predicate' : ''}`);
-        return this.signerAccount(account.account);
-    }
-    /**
-     * Tracks and returns an account that supports partial or full multisig signing.
-     *
-     * @example
-     * ```typescript
-     * const account = accountManager.multisig({version: 1, threshold: 1, addrs: ["ADDRESS1...", "ADDRESS2..."]},
-     *  [(await accountManager.fromEnvironment('ACCOUNT1')).account])
-     * ```
-     * @param multisigParams The parameters that define the multisig account
-     * @param signingAccounts The signers that are currently present
-     * @returns A multisig account wrapper
-     */
-    multisig(multisigParams, signingAccounts) {
-        return this.signerAccount(new MultisigAccount(multisigParams, signingAccounts));
-    }
-    /**
-     * Tracks and returns an account that represents a logic signature.
-     *
-     * @example
-     * ```typescript
-     * const account = accountManager.logicsig(program, [new Uint8Array(3, ...)])
-     * ```
-     * @param program The bytes that make up the compiled logic signature
-     * @param args The (binary) arguments to pass into the logic signature
-     * @returns A logic signature account wrapper
-     */
-    logicsig(program, args) {
-        return this.signerAccount(new LogicSigAccount(program, args));
-    }
-    /**
-     * Tracks and returns a new, random Algorand account with secret key loaded.
-     *
-     * @example
-     * ```typescript
-     * const account = accountManager.random()
-     * ```
-     * @returns The account
-     */
-    random() {
-        return this.signerAccount(algosdk.generateAccount());
-    }
-    /**
-     * Returns an account (with private key loaded) that can act as a dispenser from
-     * environment variables, or against default LocalNet if no environment variables present.
-     *
-     * Note: requires a Node.js environment to execute.
-     *
-     * If present, it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC and optionally
-     * process.env.DISPENSER_SENDER if it's a rekeyed account.
-     *
-     * @example
-     * ```typescript
-     * const account = await accountManager.dispenserFromEnvironment()
-     * ```
-     *
-     * @returns The account
-     */
-    async dispenserFromEnvironment() {
-        if (!process || !process.env) {
-            throw new Error('Attempt to get dispenser from environment from a non Node.js context; this is not supported!');
-        }
-        return process.env[`${DISPENSER_ACCOUNT.toUpperCase()}_MNEMONIC`]
-            ? await this.fromEnvironment(DISPENSER_ACCOUNT)
-            : await this.localNetDispenser();
-    }
-    /**
-     * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts).
-     *
-     * @example
-     * ```typescript
-     * const account = await accountManager.localNetDispenser()
-     * ```
-     * @returns The account
-     */
-    async localNetDispenser() {
-        const dispenser = await this._kmdAccountManager.getLocalNetDispenserAccount();
-        return this.signerAccount(dispenser.account);
-    }
-    /**
-     * Rekey an account to a new address.
-     *
-     * **Note:** Please be careful with this function and be sure to read the [official rekey guidance](https://dev.algorand.co/concepts/accounts/rekeying).
-     *
-     * @param account The account to rekey
-     * @param rekeyTo The account address or signing account of the account that will be used to authorise transactions for the rekeyed account going forward.
-     *  If a signing account is provided that will now be tracked as the signer for `account` in this `AccountManager`
-     * @param options Any parameters to control the transaction or execution of the transaction
-     *
-     * @example Basic example (with string addresses)
-     * ```typescript
-     * await accountManager.rekeyAccount({account: "ACCOUNTADDRESS", rekeyTo: "NEWADDRESS"})
-     * ```
-     * @example Basic example (with signer accounts)
-     * ```typescript
-     * await accountManager.rekeyAccount({account: account1, rekeyTo: newSignerAccount})
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * await accountManager.rekeyAccount({
-     *   account: "ACCOUNTADDRESS",
-     *   rekeyTo: "NEWADDRESS",
-     *   lease: 'lease',
-     *   note: 'note',
-     *   firstValidRound: 1000n,
-     *   validityWindow: 10,
-     *   extraFee: (1000).microAlgo(),
-     *   staticFee: (1000).microAlgo(),
-     *   // Max fee doesn't make sense with extraFee AND staticFee
-     *   //  already specified, but here for completeness
-     *   maxFee: (3000).microAlgo(),
-     *   maxRoundsToWaitForConfirmation: 5,
-     *   suppressLog: true,
-     * })
-     * ```
-     * @returns The result of the transaction and the transaction that was sent
-     */
-    async rekeyAccount(account, rekeyTo, options) {
-        const result = await this._getComposer()
-            .addPayment({
-            ...options,
-            sender: address(account),
-            receiver: address(account),
-            amount: AlgoAmount.MicroAlgo(0),
-            rekeyTo: address(typeof rekeyTo === 'object' && 'addr' in rekeyTo ? rekeyTo.addr : rekeyTo),
-        })
-            .send(options);
-        // If the rekey is a signing account set it as the signer for this account
-        if (typeof rekeyTo === 'object' && 'addr' in rekeyTo) {
-            this.rekeyed(account, rekeyTo);
-        }
-        Config.getLogger(options?.suppressLog).info(`Rekeyed ${account} to ${rekeyTo} via transaction ${result.txIds.at(-1)}`);
-        return { ...result, transaction: result.transactions.at(-1), confirmation: result.confirmations.at(-1) };
-    }
-    async _getEnsureFundedAmount(sender, minSpendingBalance, minFundingIncrement) {
-        const accountInfo = await this.getInformation(sender);
-        const currentSpendingBalance = accountInfo.balance.microAlgo - accountInfo.minBalance.microAlgo;
-        const amountFunded = calculateFundAmount(minSpendingBalance.microAlgo, currentSpendingBalance, minFundingIncrement?.microAlgo ?? 0n);
-        return amountFunded === null ? undefined : AlgoAmount.MicroAlgo(amountFunded);
-    }
-    /**
-     * Funds a given account using a dispenser account as a funding source such that
-     * the given account has a certain amount of Algo free to spend (accounting for
-     * Algo locked in minimum balance requirement).
-     *
-     * https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr
-     *
-     * @param accountToFund The account to fund
-     * @param dispenserAccount The account to use as a dispenser funding source
-     * @param minSpendingBalance The minimum balance of Algo that the account should have available to spend (i.e. on top of minimum balance requirement)
-     * @param options Optional parameters to control the funding increment, transaction or execution of the transaction
-     * @example Example using AlgorandClient
-     * ```typescript
-     * // Basic example
-     * await accountManager.ensureFunded("ACCOUNTADDRESS", "DISPENSERADDRESS", algokit.algo(1))
-     * // With configuration
-     * await accountManager.ensureFunded("ACCOUNTADDRESS", "DISPENSERADDRESS", algokit.algo(1),
-     *  { minFundingIncrement: algokit.algo(2), fee: (1000).microAlgo(), suppressLog: true }
-     * )
-     * ```
-     * @returns
-     * - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
-     * - `undefined` if no funds were needed.
-     */
-    async ensureFunded(accountToFund, dispenserAccount, minSpendingBalance, options) {
-        const addressToFund = address(accountToFund);
-        const amountFunded = await this._getEnsureFundedAmount(addressToFund, minSpendingBalance, options?.minFundingIncrement);
-        if (!amountFunded)
-            return undefined;
-        const result = await this._getComposer()
-            .addPayment({
-            ...options,
-            sender: address(dispenserAccount),
-            receiver: addressToFund,
-            amount: amountFunded,
-        })
-            .send(options);
-        return {
-            ...result,
-            transaction: result.transactions[0],
-            confirmation: result.confirmations[0],
-            transactionId: result.txIds[0],
-            amountFunded: amountFunded,
-        };
-    }
-    /**
-     * Funds a given account using a dispenser account retrieved from the environment,
-     * per the `dispenserFromEnvironment` method, as a funding source such that
-     * the given account has a certain amount of Algo free to spend (accounting for
-     * Algo locked in minimum balance requirement).
-     *
-     * **Note:** requires a Node.js environment to execute.
-     *
-     * The dispenser account is retrieved from the account mnemonic stored in
-     * process.env.DISPENSER_MNEMONIC and optionally process.env.DISPENSER_SENDER
-     * if it's a rekeyed account, or against default LocalNet if no environment variables present.
-     *
-     * https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr
-     *
-     * @param accountToFund The account to fund
-     * @param minSpendingBalance The minimum balance of Algo that the account should have available to spend (i.e. on top of minimum balance requirement)
-     * @param options Optional parameters to control the funding increment, transaction or execution of the transaction
-     * @example Example using AlgorandClient
-     * ```typescript
-     * // Basic example
-     * await accountManager.ensureFundedFromEnvironment("ACCOUNTADDRESS", algokit.algo(1))
-     * // With configuration
-     * await accountManager.ensureFundedFromEnvironment("ACCOUNTADDRESS", algokit.algo(1),
-     *  { minFundingIncrement: algokit.algo(2), fee: (1000).microAlgo(), suppressLog: true }
-     * )
-     * ```
-     * @returns
-     * - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
-     * - `undefined` if no funds were needed.
-     */
-    async ensureFundedFromEnvironment(accountToFund, minSpendingBalance, options) {
-        const addressToFund = address(accountToFund);
-        const dispenserAccount = await this.dispenserFromEnvironment();
-        const amountFunded = await this._getEnsureFundedAmount(addressToFund, minSpendingBalance, options?.minFundingIncrement);
-        if (!amountFunded)
-            return undefined;
-        const result = await this._getComposer()
-            .addPayment({
-            ...options,
-            sender: dispenserAccount,
-            receiver: addressToFund,
-            amount: amountFunded,
-        })
-            .send(options);
-        return {
-            ...result,
-            transaction: result.transactions[0],
-            confirmation: result.confirmations[0],
-            transactionId: result.txIds[0],
-            amountFunded: amountFunded,
-        };
-    }
-    /**
-     * Funds a given account using the TestNet Dispenser API as a funding source such that
-     * the account has a certain amount of Algo free to spend (accounting for Algo locked
-     * in minimum balance requirement).
-     *
-     * https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr
-     *
-     * @param accountToFund The account to fund
-     * @param dispenserClient The TestNet dispenser funding client
-     * @param minSpendingBalance The minimum balance of Algo that the account should have available to spend (i.e. on top of minimum balance requirement)
-     * @param options Optional parameters to control the funding increment, transaction or execution of the transaction
-     * @example Example using AlgorandClient
-     * ```typescript
-     * // Basic example
-     * await accountManager.ensureFundedFromTestNetDispenserApi("ACCOUNTADDRESS", algorand.client.getTestNetDispenserFromEnvironment(), algokit.algo(1))
-     * // With configuration
-     * await accountManager.ensureFundedFromTestNetDispenserApi("ACCOUNTADDRESS", algorand.client.getTestNetDispenserFromEnvironment(), algokit.algo(1),
-     *  { minFundingIncrement: algokit.algo(2) }
-     * )
-     * ```
-     * @returns
-     * - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
-     * - `undefined` if no funds were needed.
-     */
-    async ensureFundedFromTestNetDispenserApi(accountToFund, dispenserClient, minSpendingBalance, options) {
-        if (!(await this._clientManager.isTestNet())) {
-            throw new Error('Attempt to fund using TestNet dispenser API on non TestNet network.');
-        }
-        const addressToFund = address(accountToFund);
-        const amountFunded = await this._getEnsureFundedAmount(addressToFund, minSpendingBalance, options?.minFundingIncrement);
-        if (!amountFunded)
-            return undefined;
-        const result = await dispenserClient.fund(addressToFund, amountFunded.microAlgo);
-        return {
-            amountFunded: AlgoAmount.MicroAlgo(result.amount),
-            transactionId: result.txId,
-        };
-    }
-}
+var AccountManager = class {
+	_clientManager;
+	_kmdAccountManager;
+	_accounts = {};
+	_defaultSigner;
+	/**
+	* Create a new account manager.
+	* @param clientManager The ClientManager client to use for algod and kmd clients
+	* @example Create a new account manager
+	* ```typescript
+	* const accountManager = new AccountManager(clientManager)
+	* ```
+	*/
+	constructor(clientManager) {
+		this._clientManager = clientManager;
+		this._kmdAccountManager = new KmdAccountManager(clientManager);
+	}
+	_getComposer(getSuggestedParams) {
+		return new TransactionComposer({
+			algod: this._clientManager.algod,
+			getSigner: this.getSigner.bind(this),
+			getSuggestedParams: getSuggestedParams ?? (() => this._clientManager.algod.suggestedParams())
+		});
+	}
+	/**
+	* KMD account manager that allows you to easily get and create accounts using KMD.
+	* @returns The `KmdAccountManager` instance.
+	* @example
+	* ```typescript
+	* const kmdManager = accountManager.kmd;
+	* ```
+	*/
+	get kmd() {
+		return this._kmdAccountManager;
+	}
+	/**
+	* Sets the default signer to use if no other signer is specified.
+	*
+	* If this isn't set an a transaction needs signing for a given sender
+	* then an error will be thrown from `getSigner` / `getAccount`.
+	* @param signer The signer to use, either a `TransactionSigner` or a `AddressWithSigner`
+	* @example
+	* ```typescript
+	* const signer = accountManager.random() // Can be anything that returns a `TransactionSigner` or `AddressWithSigner`
+	* accountManager.setDefaultSigner(signer)
+	*
+	* // When signing a transaction, if there is no signer registered for the sender then the default signer will be used
+	* const signer = accountManager.getSigner("SENDERADDRESS")
+	* ```
+	* @returns The `AccountManager` so method calls can be chained
+	*/
+	setDefaultSigner(signer) {
+		this._defaultSigner = "signer" in signer ? signer.signer : signer;
+		return this;
+	}
+	/**
+	* Records the given account (that can sign) against the address of the provided account for later
+	* retrieval and returns a `AddressWithSigner` along with the original account in an `account` property.
+	*/
+	signerAccount(account) {
+		const signer = getAccountTransactionSigner(account);
+		const acc = {
+			addr: account.addr,
+			signer
+		};
+		this._accounts[acc.addr.toString()] = acc;
+		const addressWithAccount = Address.fromString(acc.addr.toString());
+		addressWithAccount.account = account;
+		addressWithAccount.addr = acc.addr;
+		addressWithAccount.signer = signer;
+		return addressWithAccount;
+	}
+	/**
+	* Tracks the given account for later signing.
+	*
+	* Note: If you are generating accounts via the various methods on `AccountManager`
+	* (like `random`, `fromMnemonic`, `logicsig`, etc.) then they automatically get tracked.
+	* @param account The account to register, which can be a `AddressWithSigner` or
+	*  a `algosdk.Account`, `algosdk.LogicSigAccount`, `SigningAccount` or `MultisigAccount`
+	* @example
+	* ```typescript
+	* const accountManager = new AccountManager(clientManager)
+	*  .setSignerFromAccount(algosdk.generateAccount())
+	*  .setSignerFromAccount(new algosdk.LogicSigAccount(program, args))
+	*  .setSignerFromAccount(new SigningAccount(mnemonic, sender))
+	*  .setSignerFromAccount(new MultisigAccount({version: 1, threshold: 1, addrs: ["ADDRESS1...", "ADDRESS2..."]}, [account1, account2]))
+	*  .setSignerFromAccount({addr: "SENDERADDRESS", signer: transactionSigner})
+	* ```
+	* @returns The `AccountManager` instance for method chaining
+	*/
+	setSignerFromAccount(account) {
+		this.signerAccount(account);
+		return this;
+	}
+	/**
+	* Tracks the given `TransactionSigner` against the given sender address for later signing.
+	* @param sender The sender address to use this signer for
+	* @param signer The `TransactionSigner` to sign transactions with for the given sender
+	* @example
+	* ```typescript
+	* const accountManager = new AccountManager(clientManager)
+	*  .setSigner("SENDERADDRESS", transactionSigner)
+	* ```
+	* @returns The `AccountManager` instance for method chaining
+	*/
+	setSigner(sender, signer) {
+		this._accounts[getAddress(sender).toString()] = {
+			addr: getAddress(sender),
+			signer
+		};
+		return this;
+	}
+	/**
+	* Takes all registered signers from the given `AccountManager` and adds them to this `AccountManager`.
+	*
+	* This is useful for situations where you have multiple contexts you are building accounts in such as unit tests.
+	* @param anotherAccountManager Another account manager with signers registered
+	* @param overwriteExisting Whether or not to overwrite any signers that have the same sender address with the ones in the other account manager or not (default: true)
+	* @returns The `AccountManager` instance for method chaining
+	* @example
+	* ```typescript
+	* accountManager2.setSigners(accountManager1);
+	* ```
+	*/
+	setSigners(anotherAccountManager, overwriteExisting = true) {
+		this._accounts = overwriteExisting ? {
+			...this._accounts,
+			...anotherAccountManager._accounts
+		} : {
+			...anotherAccountManager._accounts,
+			...this._accounts
+		};
+		return this;
+	}
+	/**
+	* Returns the `TransactionSigner` for the given sender address, ready to sign a transaction for that sender.
+	*
+	* If no signer has been registered for that address then the default signer is used if registered and
+	* if not then an error is thrown.
+	*
+	* @param sender The sender address
+	* @example
+	* ```typescript
+	* const signer = accountManager.getSigner("SENDERADDRESS")
+	* ```
+	* @returns The `TransactionSigner` or throws an error if not found and no default signer is set
+	*/
+	getSigner(sender) {
+		const signer = this._accounts[getAddress(sender).toString()]?.signer ?? this._defaultSigner;
+		if (!signer) throw new Error(`No signer found for address ${sender}`);
+		return signer;
+	}
+	/**
+	* Returns the `AddressWithSigner` for the given sender address.
+	*
+	* If no signer has been registered for that address then an error is thrown.
+	* @param sender The sender address
+	* @example
+	* ```typescript
+	* const sender = accountManager.random()
+	* // ...
+	* // Returns the `AddressWithSigner` for `sender` that has previously been registered
+	* const account = accountManager.getAccount(sender)
+	* ```
+	* @returns The `AddressWithSigner` or throws an error if not found
+	*/
+	getAccount(sender) {
+		const account = this._accounts[getAddress(sender).toString()];
+		if (!account) throw new Error(`No signer found for address ${sender}`);
+		return account;
+	}
+	/**
+	* Returns the given sender account's current status, balance and spendable amounts.
+	*
+	* [Response data schema details](https://dev.algorand.co/reference/rest-apis/algod/#accountinformation)
+	* @example
+	* ```typescript
+	* const address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA";
+	* const accountInfo = await accountManager.getInformation(address);
+	* ```
+	*
+	* @param sender The account / address to look up
+	* @returns The account information
+	*/
+	async getInformation(sender) {
+		const senderAddress = getAddress(sender).toString();
+		const { round, lastHeartbeat = void 0, lastProposed = void 0, address,...account } = await this._clientManager.algod.accountInformation(senderAddress);
+		return {
+			...account,
+			authAddr: account.authAddr,
+			address,
+			balance: AlgoAmount.MicroAlgo(Number(account.amount)),
+			amountWithoutPendingRewards: AlgoAmount.MicroAlgo(Number(account.amountWithoutPendingRewards)),
+			minBalance: AlgoAmount.MicroAlgo(Number(account.minBalance)),
+			pendingRewards: AlgoAmount.MicroAlgo(Number(account.pendingRewards)),
+			rewards: AlgoAmount.MicroAlgo(Number(account.rewards)),
+			validAsOfRound: BigInt(round),
+			totalAppsOptedIn: Number(account.totalAppsOptedIn),
+			totalAssetsOptedIn: Number(account.totalAssetsOptedIn),
+			totalCreatedApps: Number(account.totalCreatedApps),
+			totalCreatedAssets: Number(account.totalCreatedAssets),
+			appsTotalExtraPages: account.appsTotalExtraPages !== void 0 ? Number(account.appsTotalExtraPages) : void 0,
+			rewardBase: account.rewardBase !== void 0 ? Number(account.rewardBase) : void 0,
+			totalBoxBytes: account.totalBoxBytes !== void 0 ? Number(account.totalBoxBytes) : void 0,
+			totalBoxes: account.totalBoxes !== void 0 ? Number(account.totalBoxes) : void 0,
+			lastHeartbeatRound: lastHeartbeat !== void 0 ? BigInt(lastHeartbeat) : void 0,
+			lastProposedRound: lastProposed !== void 0 ? BigInt(lastProposed) : void 0
+		};
+	}
+	/**
+	* Tracks and returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
+	*
+	* @example
+	* ```typescript
+	* const account = accountManager.fromMnemonic("mnemonic secret ...")
+	* const rekeyedAccount = accountManager.fromMnemonic("mnemonic secret ...", "SENDERADDRESS...")
+	* ```
+	* @param mnemonicSecret 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)
+	* @returns The account
+	*/
+	fromMnemonic(mnemonicSecret, sender) {
+		const seed = seedFromMnemonic(mnemonicSecret);
+		const keypair = nacl.sign.keyPair.fromSeed(seed);
+		const addrWithSigners = generateAddressWithSigners({
+			ed25519Pubkey: keypair.publicKey,
+			sendingAddress: getOptionalAddress(sender),
+			rawEd25519Signer: async (bytesToSign) => {
+				return nacl.sign.detached(bytesToSign, keypair.secretKey);
+			}
+		});
+		return this.signerAccount(addrWithSigners);
+	}
+	/**
+	* Tracks and returns an Algorand account that is a rekeyed version of the given account to a new sender.
+	*
+	* @example
+	* ```typescript
+	* const account = accountManager.fromMnemonic("mnemonic secret ...")
+	* const rekeyedAccount = accountManager.rekeyed(account, "SENDERADDRESS...")
+	* ```
+	* @param account The account to use as the signer for this new rekeyed account
+	* @param sender The sender address to use as the new sender
+	* @returns The account
+	*/
+	rekeyed(sender, account) {
+		return this.signerAccount({
+			addr: getAddress(sender),
+			signer: account.signer
+		});
+	}
+	/**
+	* Tracks and returns an Algorand account with private key loaded by convention from environment variables based on the given name identifier.
+	*
+	* Note: This function expects to run in a Node.js environment.
+	*
+	* ## Convention:
+	* * **Non-LocalNet:** will load process.env['\{NAME\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,
+	*  never commit it into source control and ideally load it via a secret storage service rather than the file system.
+	*   If process.env['\{NAME\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)
+	* * **LocalNet:** will load the account from a KMD wallet called \{NAME\} and if that wallet doesn't exist it will create it and fund the account for you
+	*
+	* This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).
+	*
+	* @example Default
+	*
+	* If you have a mnemonic secret loaded into `process.env.MY_ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:
+	* ```typescript
+	* const account = await accountManager.fromEnvironment('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 1000 (default) ALGO from the default LocalNet dispenser.
+	* If not running against LocalNet then it will use proces.env.MY_ACCOUNT_MNEMONIC as the private key and (if present) process.env.MY_ACCOUNT_SENDER as the sender address.
+	*
+	* @param name The name identifier of the account
+	* @param fundWith The optional amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account
+	* @returns The account
+	*/
+	async fromEnvironment(name, fundWith) {
+		if (!process || !process.env) throw new Error("Attempt to get account with private key from a non Node.js context; this is not supported!");
+		const accountMnemonic = process.env[`${name.toUpperCase()}_MNEMONIC`];
+		const sender = process.env[`${name.toUpperCase()}_SENDER`];
+		if (accountMnemonic) return this.fromMnemonic(accountMnemonic, sender);
+		if (await this._clientManager.isLocalNet()) {
+			const account = await this._kmdAccountManager.getOrCreateWalletAccount(name, fundWith);
+			return this.signerAccount(account);
+		}
+		throw new Error(`Missing environment variable ${name.toUpperCase()}_MNEMONIC when looking for account ${name}`);
+	}
+	/**
+	* Tracks and returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
+	*
+	* @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)
+	* @param sender The optional sender address to use this signer for (aka a rekeyed account)
+	* @example Get default funded account in a LocalNet
+	*
+	* ```typescript
+	* const defaultDispenserAccount = await accountManager.fromKmd('unencrypted-default-wallet',
+	*   a => a.status !== 'Offline' && a.amount > 1_000_000_000
+	* )
+	* ```
+	* @returns The account
+	*/
+	async fromKmd(name, predicate, sender) {
+		const account = await this._kmdAccountManager.getWalletAccount(name, predicate, sender);
+		if (!account) throw new Error(`Unable to find KMD account ${name}${predicate ? " with predicate" : ""}`);
+		return this.signerAccount(account);
+	}
+	/**
+	* Tracks and returns an account that supports partial or full multisig signing.
+	*
+	* @example
+	* ```typescript
+	* const account = accountManager.multisig({version: 1, threshold: 1, addrs: ["ADDRESS1...", "ADDRESS2..."]},
+	*  [(await accountManager.fromEnvironment('ACCOUNT1')).account])
+	* ```
+	* @param multisigParams The parameters that define the multisig account
+	* @param subSigners The signers that are currently present
+	* @returns A multisig account wrapper
+	*/
+	multisig(multisigParams, subSigners) {
+		return this.signerAccount(new MultisigAccount(multisigParams, subSigners));
+	}
+	/**
+	* Tracks and returns an account that represents a logic signature.
+	*
+	* @example
+	* ```typescript
+	* const account = accountManager.logicsig(program, [new Uint8Array(3, ...)])
+	* ```
+	* @param program The bytes that make up the compiled logic signature
+	* @param args The (binary) arguments to pass into the logic signature
+	* @returns A logic signature account wrapper
+	*/
+	logicsig(program, args) {
+		return this.signerAccount(new LogicSigAccount(program, args));
+	}
+	/**
+	* Tracks and returns a new, random Algorand account with secret key loaded.
+	*
+	* @example
+	* ```typescript
+	* const account = accountManager.random()
+	* ```
+	* @returns The account
+	*/
+	random() {
+		const keypair = nacl.sign.keyPair();
+		const rawSigner = async (bytesToSign) => {
+			return nacl.sign.detached(bytesToSign, keypair.secretKey);
+		};
+		return this.signerAccount(generateAddressWithSigners({
+			ed25519Pubkey: keypair.publicKey,
+			rawEd25519Signer: rawSigner
+		}));
+	}
+	/**
+	* Returns an account (with private key loaded) that can act as a dispenser from
+	* environment variables, or against default LocalNet if no environment variables present.
+	*
+	* Note: requires a Node.js environment to execute.
+	*
+	* If present, it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC and optionally
+	* process.env.DISPENSER_SENDER if it's a rekeyed account.
+	*
+	* @example
+	* ```typescript
+	* const account = await accountManager.dispenserFromEnvironment()
+	* ```
+	*
+	* @returns The account
+	*/
+	async dispenserFromEnvironment() {
+		if (!process || !process.env) throw new Error("Attempt to get dispenser from environment from a non Node.js context; this is not supported!");
+		return process.env[`${DISPENSER_ACCOUNT.toUpperCase()}_MNEMONIC`] ? await this.fromEnvironment(DISPENSER_ACCOUNT) : await this.localNetDispenser();
+	}
+	/**
+	* Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts).
+	*
+	* @example
+	* ```typescript
+	* const account = await accountManager.localNetDispenser()
+	* ```
+	* @returns The account
+	*/
+	async localNetDispenser() {
+		const dispenser = await this._kmdAccountManager.getLocalNetDispenserAccount();
+		return this.signerAccount(dispenser);
+	}
+	/**
+	* Rekey an account to a new address.
+	*
+	* **Note:** Please be careful with this function and be sure to read the [official rekey guidance](https://dev.algorand.co/concepts/accounts/rekeying).
+	*
+	* @param account The account to rekey
+	* @param rekeyTo The account address or signing account of the account that will be used to authorise transactions for the rekeyed account going forward.
+	*  If a signing account is provided that will now be tracked as the signer for `account` in this `AccountManager`
+	* @param options Any parameters to control the transaction or execution of the transaction
+	*
+	* @example Basic example (with string addresses)
+	* ```typescript
+	* await accountManager.rekeyAccount({account: "ACCOUNTADDRESS", rekeyTo: "NEWADDRESS"})
+	* ```
+	* @example Basic example (with signer accounts)
+	* ```typescript
+	* await accountManager.rekeyAccount({account: account1, rekeyTo: newSignerAccount})
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* await accountManager.rekeyAccount({
+	*   account: "ACCOUNTADDRESS",
+	*   rekeyTo: "NEWADDRESS",
+	*   lease: 'lease',
+	*   note: 'note',
+	*   firstValidRound: 1000n,
+	*   validityWindow: 10,
+	*   extraFee: (1000).microAlgo(),
+	*   staticFee: (1000).microAlgo(),
+	*   // Max fee doesn't make sense with extraFee AND staticFee
+	*   //  already specified, but here for completeness
+	*   maxFee: (3000).microAlgo(),
+	*   maxRoundsToWaitForConfirmation: 5,
+	*   suppressLog: true,
+	* })
+	* ```
+	* @returns The result of the transaction and the transaction that was sent
+	*/
+	async rekeyAccount(account, rekeyTo, options) {
+		const result = await this._getComposer().addPayment({
+			...options,
+			sender: getAddress(account),
+			receiver: getAddress(account),
+			amount: AlgoAmount.MicroAlgo(0),
+			rekeyTo: getAddress(rekeyTo)
+		}).send(options);
+		if (typeof rekeyTo === "object" && "addr" in rekeyTo) this.rekeyed(account, rekeyTo);
+		Config.getLogger(options?.suppressLog).info(`Rekeyed ${account} to ${rekeyTo} via transaction ${result.txIds.at(-1)}`);
+		return {
+			...result,
+			transaction: result.transactions.at(-1),
+			confirmation: result.confirmations.at(-1)
+		};
+	}
+	async _getEnsureFundedAmount(sender, minSpendingBalance, minFundingIncrement) {
+		const accountInfo = await this.getInformation(sender);
+		const currentSpendingBalance = accountInfo.balance.microAlgo - accountInfo.minBalance.microAlgo;
+		const amountFunded = calculateFundAmount(minSpendingBalance.microAlgo, currentSpendingBalance, minFundingIncrement?.microAlgo ?? 0n);
+		return amountFunded === null ? void 0 : AlgoAmount.MicroAlgo(amountFunded);
+	}
+	/**
+	* Funds a given account using a dispenser account as a funding source such that
+	* the given account has a certain amount of Algo free to spend (accounting for
+	* Algo locked in minimum balance requirement).
+	*
+	* https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr
+	*
+	* @param accountToFund The account to fund
+	* @param dispenserAccount The account to use as a dispenser funding source
+	* @param minSpendingBalance The minimum balance of Algo that the account should have available to spend (i.e. on top of minimum balance requirement)
+	* @param options Optional parameters to control the funding increment, transaction or execution of the transaction
+	* @example Example using AlgorandClient
+	* ```typescript
+	* // Basic example
+	* await accountManager.ensureFunded("ACCOUNTADDRESS", "DISPENSERADDRESS", algokit.algo(1))
+	* // With configuration
+	* await accountManager.ensureFunded("ACCOUNTADDRESS", "DISPENSERADDRESS", algokit.algo(1),
+	*  { minFundingIncrement: algokit.algo(2), fee: (1000).microAlgo(), suppressLog: true }
+	* )
+	* ```
+	* @returns
+	* - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
+	* - `undefined` if no funds were needed.
+	*/
+	async ensureFunded(accountToFund, dispenserAccount, minSpendingBalance, options) {
+		const addressToFund = getAddress(accountToFund);
+		const amountFunded = await this._getEnsureFundedAmount(addressToFund, minSpendingBalance, options?.minFundingIncrement);
+		if (!amountFunded) return void 0;
+		const result = await this._getComposer().addPayment({
+			...options,
+			sender: getAddress(dispenserAccount),
+			receiver: addressToFund,
+			amount: amountFunded
+		}).send(options);
+		return {
+			...result,
+			transaction: result.transactions[0],
+			confirmation: result.confirmations[0],
+			transactionId: result.txIds[0],
+			amountFunded
+		};
+	}
+	/**
+	* Funds a given account using a dispenser account retrieved from the environment,
+	* per the `dispenserFromEnvironment` method, as a funding source such that
+	* the given account has a certain amount of Algo free to spend (accounting for
+	* Algo locked in minimum balance requirement).
+	*
+	* **Note:** requires a Node.js environment to execute.
+	*
+	* The dispenser account is retrieved from the account mnemonic stored in
+	* process.env.DISPENSER_MNEMONIC and optionally process.env.DISPENSER_SENDER
+	* if it's a rekeyed account, or against default LocalNet if no environment variables present.
+	*
+	* https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr
+	*
+	* @param accountToFund The account to fund
+	* @param minSpendingBalance The minimum balance of Algo that the account should have available to spend (i.e. on top of minimum balance requirement)
+	* @param options Optional parameters to control the funding increment, transaction or execution of the transaction
+	* @example Example using AlgorandClient
+	* ```typescript
+	* // Basic example
+	* await accountManager.ensureFundedFromEnvironment("ACCOUNTADDRESS", algokit.algo(1))
+	* // With configuration
+	* await accountManager.ensureFundedFromEnvironment("ACCOUNTADDRESS", algokit.algo(1),
+	*  { minFundingIncrement: algokit.algo(2), fee: (1000).microAlgo(), suppressLog: true }
+	* )
+	* ```
+	* @returns
+	* - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
+	* - `undefined` if no funds were needed.
+	*/
+	async ensureFundedFromEnvironment(accountToFund, minSpendingBalance, options) {
+		const addressToFund = getAddress(accountToFund);
+		const dispenserAccount = await this.dispenserFromEnvironment();
+		const amountFunded = await this._getEnsureFundedAmount(addressToFund, minSpendingBalance, options?.minFundingIncrement);
+		if (!amountFunded) return void 0;
+		const result = await this._getComposer().addPayment({
+			...options,
+			sender: dispenserAccount,
+			receiver: addressToFund,
+			amount: amountFunded
+		}).send(options);
+		return {
+			...result,
+			transaction: result.transactions[0],
+			confirmation: result.confirmations[0],
+			transactionId: result.txIds[0],
+			amountFunded
+		};
+	}
+	/**
+	* Funds a given account using the TestNet Dispenser API as a funding source such that
+	* the account has a certain amount of Algo free to spend (accounting for Algo locked
+	* in minimum balance requirement).
+	*
+	* https://dev.algorand.co/concepts/smart-contracts/costs-constraints#mbr
+	*
+	* @param accountToFund The account to fund
+	* @param dispenserClient The TestNet dispenser funding client
+	* @param minSpendingBalance The minimum balance of Algo that the account should have available to spend (i.e. on top of minimum balance requirement)
+	* @param options Optional parameters to control the funding increment, transaction or execution of the transaction
+	* @example Example using AlgorandClient
+	* ```typescript
+	* // Basic example
+	* await accountManager.ensureFundedFromTestNetDispenserApi("ACCOUNTADDRESS", algorand.client.getTestNetDispenserFromEnvironment(), algokit.algo(1))
+	* // With configuration
+	* await accountManager.ensureFundedFromTestNetDispenserApi("ACCOUNTADDRESS", algorand.client.getTestNetDispenserFromEnvironment(), algokit.algo(1),
+	*  { minFundingIncrement: algokit.algo(2) }
+	* )
+	* ```
+	* @returns
+	* - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
+	* - `undefined` if no funds were needed.
+	*/
+	async ensureFundedFromTestNetDispenserApi(accountToFund, dispenserClient, minSpendingBalance, options) {
+		if (!await this._clientManager.isTestNet()) throw new Error("Attempt to fund using TestNet dispenser API on non TestNet network.");
+		const addressToFund = getAddress(accountToFund);
+		const amountFunded = await this._getEnsureFundedAmount(addressToFund, minSpendingBalance, options?.minFundingIncrement);
+		if (!amountFunded) return void 0;
+		const result = await dispenserClient.fund(addressToFund, amountFunded.microAlgo);
+		return {
+			amountFunded: AlgoAmount.MicroAlgo(result.amount),
+			transactionId: result.txId
+		};
+	}
+};
 
+//#endregion
 export { AccountManager, getAccountTransactionSigner };
-//# sourceMappingURL=account-manager.mjs.map
+//# sourceMappingURL=account-manager.mjs.map