@algorandfoundation/algokit-utils 6.3.0-beta.1 → 7.0.0-alpha.1

package/transaction/perform-atomic-transaction-composer-simulate.d.ts

@@ -1,11 +1,13 @@
 import algosdk from 'algosdk';
 import Algodv2 = algosdk.Algodv2;
 import AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
+import modelsv2 = algosdk.modelsv2;
 /**
  * Performs a simulation of the transactions loaded into the given AtomicTransactionComposer.
+ * Uses empty transaction signers for all transactions.
+ *
  * @param atc The AtomicTransactionComposer with transaction(s) loaded.
  * @param algod An Algod client to perform the simulation.
  * @returns The simulation result, which includes various details about how the transactions would be processed.
  */
-export declare function performAtomicTransactionComposerSimulate(atc: AtomicTransactionComposer, algod: Algodv2): Promise<algosdk.modelsv2.SimulateResponse>;
-//# sourceMappingURL=perform-atomic-transaction-composer-simulate.d.ts.map
+export declare function performAtomicTransactionComposerSimulate(atc: AtomicTransactionComposer, algod: Algodv2, options?: Omit<ConstructorParameters<typeof modelsv2.SimulateRequest>[0], 'txnGroups'>): Promise<algosdk.modelsv2.SimulateResponse>;

package/transaction/transaction.d.ts

@@ -1,5 +1,6 @@
 import algosdk from 'algosdk';
 import { AlgoAmount } from '../types/amount';
+import { ABIReturn } from '../types/app';
 import { AtomicTransactionComposerToSend, SendAtomicTransactionComposerResults, SendTransactionFrom, SendTransactionParams, SendTransactionResult, TransactionGroupToSend, TransactionNote, TransactionToSign } from '../types/transaction';
 import Algodv2 = algosdk.Algodv2;
 import AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
@@ -10,7 +11,10 @@ import TransactionWithSigner = algosdk.TransactionWithSigner;
 export declare const MAX_TRANSACTION_GROUP_SIZE = 16;
 export declare const MAX_APP_CALL_FOREIGN_REFERENCES = 8;
 export declare const MAX_APP_CALL_ACCOUNT_REFERENCES = 4;
-/** Encodes a transaction note into a byte array ready to be included in an Algorand transaction.
+/**
+ * @deprecated Convert your data to a `string` or `Uint8Array`, if using ARC-2 use `TransactionComposer.arc2Note`.
+ *
+ * Encodes a transaction note into a byte array ready to be included in an Algorand transaction.
  *
  * @param note The transaction note
  * @returns the transaction note ready for inclusion in a transaction
@@ -33,12 +37,18 @@ export declare function encodeTransactionNote(note?: TransactionNote): Uint8Arra
  */
 export declare function encodeLease(lease?: string | Uint8Array): Uint8Array | undefined;
 /**
+ * @deprecated Use `algorand.client` to interact with accounts, and use `.addr` to get the address
+ * and/or move from using `SendTransactionFrom` to `TransactionSignerAccount` and use `.addr` instead.
+ *
  * Returns the public address of the given transaction sender.
  * @param sender A transaction sender
  * @returns The public address
  */
 export declare const getSenderAddress: (sender: string | SendTransactionFrom) => string;
 /**
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to construct transactions instead or
+ * construct an `algosdk.TransactionWithSigner` manually instead.
+ *
  * Given a transaction in a variety of supported formats, returns a TransactionWithSigner object ready to be passed to an
  * AtomicTransactionComposer's addTransaction method.
  * @param transaction One of: A TransactionWithSigner object (returned as is), a TransactionToSign object (signer is obtained from the
@@ -50,6 +60,9 @@ export declare const getSenderAddress: (sender: string | SendTransactionFrom) =>
  */
 export declare const getTransactionWithSigner: (transaction: TransactionWithSigner | TransactionToSign | Transaction | Promise<SendTransactionResult>, defaultSender?: SendTransactionFrom) => Promise<TransactionWithSigner>;
 /**
+ * @deprecated Use `TransactionSignerAccount` instead of `SendTransactionFrom` or use
+ * `algosdk.makeBasicAccountTransactionSigner` / `algosdk.makeLogicSigAccountTransactionSigner`.
+ *
  * Returns a `TransactionSigner` for the given transaction sender.
  * This function has memoization, so will return the same transaction signer for a given sender.
  * @param sender A transaction sender
@@ -57,13 +70,20 @@ export declare const getTransactionWithSigner: (transaction: TransactionWithSign
  */
 export declare const getSenderTransactionSigner: (val: SendTransactionFrom) => algosdk.TransactionSigner;
 /**
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to sign transactions
+ * or use the relevant underlying `account.signTxn` / `algosdk.signLogicSigTransactionObject`
+ * / `multiSigAccount.sign` / `TransactionSigner` methods directly.
+ *
  * Signs a single transaction by the given signer.
  * @param transaction The transaction to sign
  * @param signer The signer to sign
  * @returns The signed transaction as a `Uint8Array`
  */
 export declare const signTransaction: (transaction: Transaction, signer: SendTransactionFrom) => Promise<Uint8Array>;
-/** Prepares a transaction for sending and then (if instructed) signs and sends the given transaction to the chain.
+/**
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to send transactions.
+ *
+ * Prepares a transaction for sending and then (if instructed) signs and sends the given transaction to the chain.
  *
  * @param send The details for the transaction to prepare/send, including:
  *   * `transaction`: The unsigned transaction
@@ -98,21 +118,20 @@ export declare const sendTransaction: (send: {
 export declare function populateAppCallResources(atc: algosdk.AtomicTransactionComposer, algod: algosdk.Algodv2): Promise<algosdk.AtomicTransactionComposer>;
 /**
  * Signs and sends transactions that have been collected by an `AtomicTransactionComposer`.
- * @param atcSend The parameters controlling the send, including:
- *  * `atc` The `AtomicTransactionComposer`
- *  * `sendParams` The parameters to control the send behaviour
+ * @param atcSend The parameters controlling the send, including `atc` The `AtomicTransactionComposer` and params to control send behaviour
  * @param algod An algod client
  * @returns An object with transaction IDs, transactions, group transaction ID (`groupTransactionId`) if more than 1 transaction sent, and (if `skipWaiting` is `false` or unset) confirmation (`confirmation`)
  */
 export declare const sendAtomicTransactionComposer: (atcSend: AtomicTransactionComposerToSend, algod: Algodv2) => Promise<SendAtomicTransactionComposerResults>;
 /**
- * Performs a dry run of the transactions loaded into the given AtomicTransactionComposer`
- * @param atc The AtomicTransactionComposer` with transaction(s) loaded
- * @param algod An Algod client
- * @returns The dryrun result
+ * Takes an algosdk `ABIResult` and converts it to an `ABIReturn`.
+ * Converts `bigint`'s for Uint's < 64 to `number` for easier use.
+ * @param result The `ABIReturn`
  */
-export declare function performAtomicTransactionComposerDryrun(atc: AtomicTransactionComposer, algod: Algodv2): Promise<algosdk.DryrunResult>;
+export declare function getABIReturnValue(result: algosdk.ABIResult): ABIReturn;
 /**
+ * @deprecated Use `TransactionComposer` (`algorand.newGroup()`) or `AtomicTransactionComposer` to construct and send group transactions instead.
+ *
  * Signs and sends a group of [up to 16](https://developer.algorand.org/docs/get-details/atomic_transfers/#create-transactions) transactions to the chain
  *
  * @param groupSend The group details to send, with:
@@ -135,6 +154,8 @@ export declare const sendGroupOfTransactions: (groupSend: TransactionGroupToSend
  */
 export declare const waitForConfirmation: (transactionId: string, maxRoundsToWait: number | bigint, algod: Algodv2) => Promise<modelsv2.PendingTransactionResponse>;
 /**
+ * @deprecated Use `TransactionComposer` and the `maxFee` field in the transaction params instead.
+ *
  * Limit the acceptable fee to a defined amount of µAlgo.
  * This also sets the transaction to be flatFee to ensure the transaction only succeeds at
  * the estimated rate.
@@ -143,6 +164,8 @@ export declare const waitForConfirmation: (transactionId: string, maxRoundsToWai
  */
 export declare function capTransactionFee(transaction: algosdk.Transaction | SuggestedParams, maxAcceptableFee: AlgoAmount): void;
 /**
+ * @deprecated Use `TransactionComposer` and the `maxFee` and `staticFee` fields in the transaction params instead.
+ *
  * Allows for control of fees on a `Transaction` or `SuggestedParams` object
  * @param transaction The transaction or suggested params
  * @param feeControl The fee control parameters
@@ -152,23 +175,19 @@ export declare function controlFees<T extends SuggestedParams | Transaction>(tra
     maxFee?: AlgoAmount;
 }): T;
 /**
+ * @deprecated Use `suggestedParams ? { ...suggestedParams } : await algod.getTransactionParams().do()` instead
+ *
  * Returns suggested transaction parameters from algod unless some are already provided.
  * @param params Optionally provide parameters to use
  * @param algod Algod algod
  * @returns The suggested transaction parameters
  */
-export declare function getTransactionParams(params: SuggestedParams | undefined, algod: Algodv2): Promise<import("algosdk/dist/types/types/transactions/base").SuggestedParamsWithMinFee | {
-    flatFee?: boolean | undefined;
-    fee: number;
-    firstRound: number;
-    lastRound: number;
-    genesisID: string;
-    genesisHash: string;
-}>;
+export declare function getTransactionParams(params: SuggestedParams | undefined, algod: Algodv2): Promise<SuggestedParams>;
 /**
+ * @deprecated Use `atc.clone().buildGroup()` instead.
+ *
  * Returns the array of transactions currently present in the given `AtomicTransactionComposer`
  * @param atc The atomic transaction composer
  * @returns The array of transactions with signers
  */
 export declare function getAtomicTransactionComposerTransactions(atc: AtomicTransactionComposer): algosdk.TransactionWithSigner[];
-//# sourceMappingURL=transaction.d.ts.map

package/transfer/index.d.ts

@@ -1,3 +1,2 @@
 export * from './transfer';
 export * from './transfer-algos';
-//# sourceMappingURL=index.d.ts.map

package/transfer/transfer-algos.d.ts

@@ -3,7 +3,7 @@ import { SendTransactionResult } from '../types/transaction';
 import { AlgoTransferParams } from '../types/transfer';
 import Algodv2 = algosdk.Algodv2;
 /**
- * @deprecated Use `algorand.send.payment()` / `algorand.transaction.payment()` instead
+ * @deprecated Use `algorand.send.payment()` / `algorand.createTransaction.payment()` instead
  *
  * Transfer Algo between two accounts.
  * @param transfer The transfer definition
@@ -16,4 +16,3 @@ import Algodv2 = algosdk.Algodv2;
  * ```
  */
 export declare function transferAlgos(transfer: AlgoTransferParams, algod: Algodv2): Promise<SendTransactionResult>;
-//# sourceMappingURL=transfer-algos.d.ts.map

package/transfer/transfer.d.ts

@@ -20,7 +20,7 @@ import Kmd = algosdk.Kmd;
  */
 export declare function ensureFunded<T extends EnsureFundedParams>(funding: T, algod: Algodv2, kmd?: Kmd): Promise<EnsureFundedReturnType | undefined>;
 /**
- * @deprecated Use `algorand.send.assetTransfer()` / `algorand.transaction.assetTransfer()` instead
+ * @deprecated Use `algorand.send.assetTransfer()` / `algorand.createTransaction.assetTransfer()` instead
  *
  * Transfer asset between two accounts.
  * @param transfer The transfer definition
@@ -50,4 +50,3 @@ export declare function transferAsset(transfer: TransferAssetParams, algod: Algo
  * ```
  */
 export declare function rekeyAccount(rekey: AlgoRekeyParams, algod: Algodv2): Promise<SendTransactionResult>;
-//# sourceMappingURL=transfer.d.ts.map

package/types/account-manager.d.ts

@@ -1,11 +1,11 @@
-import algosdk from 'algosdk';
+import algosdk, { Address } from 'algosdk';
 import { AccountInformation, MultisigAccount, SigningAccount, TransactionSignerAccount } from './account';
-import { SendSingleTransactionResult } from './algorand-client-transaction-sender';
 import { AlgoAmount } from './amount';
 import { ClientManager } from './client-manager';
-import { CommonTransactionParams, ExecuteParams } from './composer';
+import { CommonTransactionParams } from './composer';
 import { TestNetDispenserApiClient } from './dispenser-client';
 import { KmdAccountManager } from './kmd-account-manager';
+import { SendParams, SendSingleTransactionResult } from './transaction';
 import LogicSigAccount = algosdk.LogicSigAccount;
 import Account = algosdk.Account;
 /** Result from performing an ensureFunded call. */
@@ -92,7 +92,16 @@ export declare class AccountManager {
      * ```
      * @returns The `AccountManager` instance for method chaining
      */
-    setSigner(sender: string, signer: algosdk.TransactionSigner): this;
+    setSigner(sender: string | Address, signer: algosdk.TransactionSigner): 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
+     */
+    setSigners(anotherAccountManager: AccountManager, overwriteExisting?: boolean): void;
     /**
      * Returns the `TransactionSigner` for the given sender address, ready to sign a transaction for that sender.
      *
@@ -106,7 +115,7 @@ export declare class AccountManager {
      * ```
      * @returns The `TransactionSigner` or throws an error if not found and no default signer is set
      */
-    getSigner(sender: string): algosdk.TransactionSigner;
+    getSigner(sender: string | Address): algosdk.TransactionSigner;
     /**
      * Returns the `TransactionSignerAccount` for the given sender address.
      *
@@ -114,14 +123,14 @@ export declare class AccountManager {
      * @param sender The sender address
      * @example
      * ```typescript
-     * const sender = accountManager.random().addr
+     * 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: string): TransactionSignerAccount;
+    getAccount(sender: string | Address): TransactionSignerAccount;
     /**
      * Returns the given sender account's current status, balance and spendable amounts.
      *
@@ -135,7 +144,7 @@ export declare class AccountManager {
      * @param sender The account / address to look up
      * @returns The account information
      */
-    getInformation(sender: string | TransactionSignerAccount): Promise<AccountInformation>;
+    getInformation(sender: string | Address): Promise<AccountInformation>;
     /**
      * Tracks and returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
      *
@@ -149,7 +158,7 @@ export declare class AccountManager {
      * @param sender The optional sender address to use this signer for (aka a rekeyed account)
      * @returns The account
      */
-    fromMnemonic(mnemonicSecret: string, sender?: string): TransactionSignerAccount & {
+    fromMnemonic(mnemonicSecret: string, sender?: string | Address): algosdk.Address & TransactionSignerAccount & {
         account: SigningAccount;
     };
     /**
@@ -164,9 +173,9 @@ export declare class AccountManager {
      * @param sender The sender address to use as the new sender
      * @returns The account
      */
-    rekeyed(sender: string, account: TransactionSignerAccount): TransactionSignerAccount & {
+    rekeyed(sender: string | Address, account: TransactionSignerAccount): algosdk.Address & TransactionSignerAccount & {
         account: {
-            addr: string;
+            addr: algosdk.Address;
             signer: algosdk.TransactionSigner;
         };
     };
@@ -197,7 +206,7 @@ export declare class AccountManager {
      * @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
      */
-    fromEnvironment(name: string, fundWith?: AlgoAmount): Promise<TransactionSignerAccount & {
+    fromEnvironment(name: string, fundWith?: AlgoAmount): Promise<algosdk.Address & TransactionSignerAccount & {
         account: SigningAccount;
     }>;
     /**
@@ -215,7 +224,7 @@ export declare class AccountManager {
      * ```
      * @returns The account
      */
-    fromKmd(name: string, predicate?: (account: Record<string, any>) => boolean, sender?: string): Promise<TransactionSignerAccount & {
+    fromKmd(name: string, predicate?: (account: Record<string, any>) => boolean, sender?: string | Address): Promise<algosdk.Address & TransactionSignerAccount & {
         account: SigningAccount;
     }>;
     /**
@@ -230,7 +239,7 @@ export declare class AccountManager {
      * @param signingAccounts The signers that are currently present
      * @returns A multisig account wrapper
      */
-    multisig(multisigParams: algosdk.MultisigMetadata, signingAccounts: (algosdk.Account | SigningAccount)[]): TransactionSignerAccount & {
+    multisig(multisigParams: algosdk.MultisigMetadata, signingAccounts: (algosdk.Account | SigningAccount)[]): algosdk.Address & TransactionSignerAccount & {
         account: MultisigAccount;
     };
     /**
@@ -244,7 +253,7 @@ export declare class AccountManager {
      * @param args The (binary) arguments to pass into the logic signature
      * @returns A logic signature account wrapper
      */
-    logicsig(program: Uint8Array, args?: Array<Uint8Array>): TransactionSignerAccount & {
+    logicsig(program: Uint8Array, args?: Array<Uint8Array>): algosdk.Address & TransactionSignerAccount & {
         account: algosdk.LogicSigAccount;
     };
     /**
@@ -256,7 +265,7 @@ export declare class AccountManager {
      * ```
      * @returns The account
      */
-    random(): TransactionSignerAccount & {
+    random(): algosdk.Address & TransactionSignerAccount & {
         account: algosdk.Account;
     };
     /**
@@ -275,7 +284,7 @@ export declare class AccountManager {
      *
      * @returns The account
      */
-    dispenserFromEnvironment(): Promise<TransactionSignerAccount & {
+    dispenserFromEnvironment(): Promise<algosdk.Address & TransactionSignerAccount & {
         account: SigningAccount;
     }>;
     /**
@@ -287,7 +296,7 @@ export declare class AccountManager {
      * ```
      * @returns The account
      */
-    localNetDispenser(): Promise<TransactionSignerAccount & {
+    localNetDispenser(): Promise<algosdk.Address & TransactionSignerAccount & {
         account: SigningAccount;
     }>;
     /**
@@ -328,7 +337,7 @@ export declare class AccountManager {
      * ```
      * @returns The result of the transaction and the transaction that was sent
      */
-    rekeyAccount(account: string | TransactionSignerAccount, rekeyTo: string | TransactionSignerAccount, options?: Omit<CommonTransactionParams, 'sender'> & ExecuteParams): Promise<SendSingleTransactionResult>;
+    rekeyAccount(account: string | Address, rekeyTo: string | Address | TransactionSignerAccount, options?: Omit<CommonTransactionParams, 'sender'> & SendParams): Promise<SendSingleTransactionResult>;
     private _getEnsureFundedAmount;
     /**
      * Funds a given account using a dispenser account as a funding source such that
@@ -354,9 +363,9 @@ export declare class AccountManager {
      * - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
      * - `undefined` if no funds were needed.
      */
-    ensureFunded(accountToFund: string | TransactionSignerAccount, dispenserAccount: string | TransactionSignerAccount, minSpendingBalance: AlgoAmount, options?: {
+    ensureFunded(accountToFund: string | Address, dispenserAccount: string | Address, minSpendingBalance: AlgoAmount, options?: {
         minFundingIncrement?: AlgoAmount;
-    } & ExecuteParams & Omit<CommonTransactionParams, 'sender'>): Promise<(SendSingleTransactionResult & EnsureFundedResult) | undefined>;
+    } & SendParams & Omit<CommonTransactionParams, 'sender'>): Promise<(SendSingleTransactionResult & EnsureFundedResult) | undefined>;
     /**
      * Funds a given account using a dispenser account retrieved from the environment,
      * per the `dispenserFromEnvironment` method, as a funding source such that
@@ -387,9 +396,9 @@ export declare class AccountManager {
      * - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
      * - `undefined` if no funds were needed.
      */
-    ensureFundedFromEnvironment(accountToFund: string | TransactionSignerAccount, minSpendingBalance: AlgoAmount, options?: {
+    ensureFundedFromEnvironment(accountToFund: string | Address, minSpendingBalance: AlgoAmount, options?: {
         minFundingIncrement?: AlgoAmount;
-    } & ExecuteParams & Omit<CommonTransactionParams, 'sender'>): Promise<(SendSingleTransactionResult & EnsureFundedResult) | undefined>;
+    } & SendParams & Omit<CommonTransactionParams, 'sender'>): Promise<(SendSingleTransactionResult & EnsureFundedResult) | undefined>;
     /**
      * 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
@@ -414,8 +423,7 @@ export declare class AccountManager {
      * - The result of executing the dispensing transaction and the `amountFunded` if funds were needed.
      * - `undefined` if no funds were needed.
      */
-    ensureFundedFromTestNetDispenserApi(accountToFund: string | TransactionSignerAccount, dispenserClient: TestNetDispenserApiClient, minSpendingBalance: AlgoAmount, options: {
+    ensureFundedFromTestNetDispenserApi(accountToFund: string | Address, dispenserClient: TestNetDispenserApiClient, minSpendingBalance: AlgoAmount, options?: {
         minFundingIncrement?: AlgoAmount;
     }): Promise<EnsureFundedResult | undefined>;
 }
-//# sourceMappingURL=account-manager.d.ts.map

package/types/account-manager.js

@@ -1,15 +1,15 @@
 'use strict';
 
 var algosdk = require('algosdk');
-var config = require('../config.js');
-var util = require('../util.js');
+var config = require('../src/config.js');
+var util = require('../src/util.js');
 var types_account = require('./account.js');
 var types_amount = require('./amount.js');
 var types_composer = require('./composer.js');
 var types_kmdAccountManager = require('./kmd-account-manager.js');
 
 var LogicSigAccount = algosdk.LogicSigAccount;
-var AccountInformationModel = algosdk.modelsv2.Account;
+const address = (address) => (typeof address === 'string' ? algosdk.Address.fromString(address) : address);
 /**
  * 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.
@@ -39,7 +39,7 @@ class AccountManager {
         this._kmdAccountManager = new types_kmdAccountManager.KmdAccountManager(clientManager);
     }
     _getComposer(getSuggestedParams) {
-        return new types_composer.default({
+        return new types_composer.TransactionComposer({
             algod: this._clientManager.algod,
             getSigner: this.getSigner.bind(this),
             getSuggestedParams: getSuggestedParams ?? (() => this._clientManager.algod.getTransactionParams().do()),
@@ -74,12 +74,18 @@ class AccountManager {
      * 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: getAccountTransactionSigner(account),
+            signer: signer,
         };
-        this._accounts[acc.addr] = acc;
-        return { ...acc, account };
+        this._accounts[acc.addr.toString()] = acc;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const addressWithAccount = algosdk.Address.fromString(acc.addr.toString());
+        addressWithAccount.account = account;
+        addressWithAccount.addr = acc.addr.toString();
+        addressWithAccount.signer = signer;
+        return addressWithAccount;
     }
     /**
      * Tracks the given account for later signing.
@@ -115,9 +121,23 @@ class AccountManager {
      * @returns The `AccountManager` instance for method chaining
      */
     setSigner(sender, signer) {
-        this._accounts[sender] = { addr: 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
+     */
+    setSigners(anotherAccountManager, overwriteExisting = true) {
+        this._accounts = overwriteExisting
+            ? { ...this._accounts, ...anotherAccountManager._accounts }
+            : { ...anotherAccountManager._accounts, ...this._accounts };
+        return;
+    }
     /**
      * Returns the `TransactionSigner` for the given sender address, ready to sign a transaction for that sender.
      *
@@ -132,7 +152,7 @@ class AccountManager {
      * @returns The `TransactionSigner` or throws an error if not found and no default signer is set
      */
     getSigner(sender) {
-        const signer = this._accounts[sender]?.signer ?? this._defaultSigner;
+        const signer = this._accounts[address(sender).toString()]?.signer ?? this._defaultSigner;
         if (!signer)
             throw new Error(`No signer found for address ${sender}`);
         return signer;
@@ -144,7 +164,7 @@ class AccountManager {
      * @param sender The sender address
      * @example
      * ```typescript
-     * const sender = accountManager.random().addr
+     * const sender = accountManager.random()
      * // ...
      * // Returns the `TransactionSignerAccount` for `sender` that has previously been registered
      * const account = accountManager.getAccount(sender)
@@ -152,7 +172,7 @@ class AccountManager {
      * @returns The `TransactionSignerAccount` or throws an error if not found
      */
     getAccount(sender) {
-        const account = this._accounts[sender];
+        const account = this._accounts[address(sender).toString()];
         if (!account)
             throw new Error(`No signer found for address ${sender}`);
         return account;
@@ -171,24 +191,27 @@ class AccountManager {
      * @returns The account information
      */
     async getInformation(sender) {
-        const account = AccountInformationModel.from_obj_for_encoding(await this._clientManager.algod.accountInformation(typeof sender === 'string' ? sender : sender.addr).do());
+        const { round, lastHeartbeat = undefined, lastProposed = undefined, address, ...account } = await this._clientManager.algod.accountInformation(sender).do();
         return {
             ...account,
-            // None of these can practically overflow 2^53
+            // None of the Number types can practically overflow 2^53
+            address: algosdk.Address.fromString(address),
             balance: types_amount.AlgoAmount.MicroAlgo(Number(account.amount)),
             amountWithoutPendingRewards: types_amount.AlgoAmount.MicroAlgo(Number(account.amountWithoutPendingRewards)),
             minBalance: types_amount.AlgoAmount.MicroAlgo(Number(account.minBalance)),
             pendingRewards: types_amount.AlgoAmount.MicroAlgo(Number(account.pendingRewards)),
             rewards: types_amount.AlgoAmount.MicroAlgo(Number(account.rewards)),
-            validAsOfRound: BigInt(account.round),
+            validAsOfRound: BigInt(round),
             totalAppsOptedIn: Number(account.totalAppsOptedIn),
             totalAssetsOptedIn: Number(account.totalAssetsOptedIn),
             totalCreatedApps: Number(account.totalCreatedApps),
             totalCreatedAssets: Number(account.totalCreatedAssets),
-            appsTotalExtraPages: account.appsTotalExtraPages ? Number(account.appsTotalExtraPages) : undefined,
-            rewardBase: account.rewardBase ? Number(account.rewardBase) : undefined,
-            totalBoxBytes: account.totalBoxBytes ? Number(account.totalBoxBytes) : undefined,
-            totalBoxes: account.totalBoxes ? Number(account.totalBoxes) : undefined,
+            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,
         };
     }
     /**
@@ -221,7 +244,7 @@ class AccountManager {
      * @returns The account
      */
     rekeyed(sender, account) {
-        return this.signerAccount({ addr: sender, signer: account.signer });
+        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.
@@ -409,15 +432,15 @@ class AccountManager {
         const result = await this._getComposer()
             .addPayment({
             ...options,
-            sender: typeof account === 'string' ? account : account.addr,
-            receiver: typeof account === 'string' ? account : account.addr,
+            sender: address(account),
+            receiver: address(account),
             amount: types_amount.AlgoAmount.MicroAlgo(0),
-            rekeyTo: typeof rekeyTo === 'string' ? rekeyTo : rekeyTo.addr,
+            rekeyTo: address(typeof rekeyTo === 'object' && 'addr' in rekeyTo ? rekeyTo.addr : rekeyTo),
         })
-            .execute(options);
+            .send(options);
         // If the rekey is a signing account set it as the signer for this account
-        if (typeof rekeyTo !== 'string') {
-            this.rekeyed(typeof account === 'string' ? account : account.addr, rekeyTo);
+        if (typeof rekeyTo === 'object' && 'addr' in rekeyTo) {
+            this.rekeyed(account, rekeyTo);
         }
         config.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) };
@@ -425,7 +448,7 @@ class AccountManager {
     async _getEnsureFundedAmount(sender, minSpendingBalance, minFundingIncrement) {
         const accountInfo = await this.getInformation(sender);
         const currentSpendingBalance = accountInfo.balance.microAlgo - accountInfo.minBalance.microAlgo;
-        const amountFunded = util.calculateFundAmount(minSpendingBalance.microAlgo, currentSpendingBalance, minFundingIncrement?.microAlgo ?? 0);
+        const amountFunded = util.calculateFundAmount(minSpendingBalance.microAlgo, currentSpendingBalance, minFundingIncrement?.microAlgo ?? 0n);
         return amountFunded === null ? undefined : types_amount.AlgoAmount.MicroAlgo(amountFunded);
     }
     /**
@@ -453,18 +476,18 @@ class AccountManager {
      * - `undefined` if no funds were needed.
      */
     async ensureFunded(accountToFund, dispenserAccount, minSpendingBalance, options) {
-        const addressToFund = typeof accountToFund === 'string' ? accountToFund : accountToFund.addr;
+        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: typeof dispenserAccount === 'string' ? dispenserAccount : dispenserAccount.addr,
+            sender: address(dispenserAccount),
             receiver: addressToFund,
             amount: amountFunded,
         })
-            .execute(options);
+            .send(options);
         return {
             ...result,
             transaction: result.transactions[0],
@@ -504,7 +527,7 @@ class AccountManager {
      * - `undefined` if no funds were needed.
      */
     async ensureFundedFromEnvironment(accountToFund, minSpendingBalance, options) {
-        const addressToFund = typeof accountToFund === 'string' ? accountToFund : accountToFund.addr;
+        const addressToFund = address(accountToFund);
         const dispenserAccount = await this.dispenserFromEnvironment();
         const amountFunded = await this._getEnsureFundedAmount(addressToFund, minSpendingBalance, options?.minFundingIncrement);
         if (!amountFunded)
@@ -512,11 +535,11 @@ class AccountManager {
         const result = await this._getComposer()
             .addPayment({
             ...options,
-            sender: dispenserAccount.addr,
+            sender: dispenserAccount,
             receiver: addressToFund,
             amount: amountFunded,
         })
-            .execute(options);
+            .send(options);
         return {
             ...result,
             transaction: result.transactions[0],
@@ -553,7 +576,7 @@ class AccountManager {
         if (!(await this._clientManager.isTestNet())) {
             throw new Error('Attempt to fund using TestNet dispenser API on non TestNet network.');
         }
-        const addressToFund = typeof accountToFund === 'string' ? accountToFund : accountToFund.addr;
+        const addressToFund = address(accountToFund);
         const amountFunded = await this._getEnsureFundedAmount(addressToFund, minSpendingBalance, options?.minFundingIncrement);
         if (!amountFunded)
             return undefined;