@algorandfoundation/algokit-utils 9.2.0 → 10.0.0-alpha.10

package/types/composer.mjs

@@ -1,1508 +1,1578 @@
-import algosdk, { Address } from 'algosdk';
-import { Config } from '../config.mjs';
-import { encodeLease, sendAtomicTransactionComposer, getABIReturnValue } from '../transaction/transaction.mjs';
-import { calculateExtraProgramPages, asJson } from '../util.mjs';
-import { AppManager } from './app-manager.mjs';
-import { EventType } from './lifecycle-events.mjs';
-import { genesisIdIsLocalNet } from './network-client.mjs';
+import { EMPTY_SIGNATURE, MAX_TRANSACTION_GROUP_SIZE } from "../packages/common/src/constants.mjs";
+import { OnApplicationComplete } from "../packages/transact/src/transactions/app-call.mjs";
+import { TransactionType } from "../packages/transact/src/transactions/transaction-type.mjs";
+import { Transaction, assignFee, calculateFee, decodeTransaction, encodeTransactionRaw, groupTransactions } from "../packages/transact/src/transactions/transaction.mjs";
+import { decodeSignedTransaction, encodeSignedTransactions } from "../packages/transact/src/transactions/signed-transaction.mjs";
+import { makeEmptyTransactionSigner } from "../packages/transact/src/signer.mjs";
+import { AlgoAmount } from "./amount.mjs";
+import { Config } from "../config.mjs";
+import { asJson } from "../util.mjs";
+import { waitForConfirmation } from "../transaction/transaction.mjs";
+import { AppManager } from "./app-manager.mjs";
+import { buildAppCall, buildAppCreate, buildAppUpdate, populateGroupResources, populateTransactionResources } from "../transactions/app-call.mjs";
+import { buildAssetOptIn, buildAssetOptOut, buildAssetTransfer } from "../transactions/asset-transfer.mjs";
+import { buildAssetConfig, buildAssetCreate, buildAssetDestroy, buildAssetFreeze } from "../transactions/asset-config.mjs";
+import { FeeDelta, FeePriority, calculateInnerFeeDelta } from "../transactions/fee-coverage.mjs";
+import { buildKeyReg } from "../transactions/key-registration.mjs";
+import { buildAppCallMethodCall, buildAppCreateMethodCall, buildAppUpdateMethodCall, extractComposerTransactionsFromAppMethodCallParams, processAppMethodCallArgs } from "../transactions/method-call.mjs";
+import { buildPayment } from "../transactions/payment.mjs";
+import { EventType } from "./lifecycle-events.mjs";
+import { genesisIdIsLocalNet } from "./network-client.mjs";
+import { Buffer } from "buffer";
 
-var AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
-var isTransactionWithSigner = algosdk.isTransactionWithSigner;
-var modelsv2 = algosdk.modelsv2;
-const address = (address) => {
-    return typeof address === 'string' ? Address.fromString(address) : address;
+//#region src/types/composer.ts
+var InvalidErrorTransformerValue = class extends Error {
+	constructor(originalError, value) {
+		super(`An error transformer returned a non-error value: ${value}. The original error before any transformation: ${originalError}`);
+	}
+};
+var ErrorTransformerError = class extends Error {
+	constructor(originalError, cause) {
+		super(`An error transformer threw an error: ${cause}. The original error before any transformation: ${originalError} `, { cause });
+	}
 };
-const MAX_TRANSACTION_GROUP_SIZE = 16;
-class InvalidErrorTransformerValue extends Error {
-    constructor(originalError, value) {
-        super(`An error transformer returned a non-error value: ${value}. The original error before any transformation: ${originalError}`);
-    }
-}
-class ErrorTransformerError extends Error {
-    constructor(originalError, cause) {
-        super(`An error transformer threw an error: ${cause}. The original error before any transformation: ${originalError} `, { cause });
-    }
-}
 /** TransactionComposer helps you compose and execute transactions as a transaction group. */
-class TransactionComposer {
-    async transformError(originalError) {
-        // Transformers only work with Error instances, so immediately return anything else
-        if (!(originalError instanceof Error)) {
-            return originalError;
-        }
-        let transformedError = originalError;
-        for (const transformer of this.errorTransformers) {
-            try {
-                transformedError = await transformer(transformedError);
-                if (!(transformedError instanceof Error)) {
-                    return new InvalidErrorTransformerValue(originalError, transformedError);
-                }
-            }
-            catch (errorFromTransformer) {
-                return new ErrorTransformerError(originalError, errorFromTransformer);
-            }
-        }
-        return transformedError;
-    }
-    /**
-     * Create a `TransactionComposer`.
-     * @param params The configuration for this composer
-     * @returns The `TransactionComposer` instance
-     */
-    constructor(params) {
-        /** The ATC used to compose the group */
-        this.atc = new algosdk.AtomicTransactionComposer();
-        /** Map of transaction index in the atc to a max logical fee.
-         * This is set using the value of either maxFee or staticFee.
-         */
-        this.txnMaxFees = new Map();
-        /** Transactions that have not yet been composed */
-        this.txns = [];
-        /** The default transaction validity window */
-        this.defaultValidityWindow = 10n;
-        /** Whether the validity window was explicitly set on construction */
-        this.defaultValidityWindowIsExplicit = false;
-        this.algod = params.algod;
-        const defaultGetSuggestedParams = () => params.algod.getTransactionParams().do();
-        this.getSuggestedParams = params.getSuggestedParams ?? defaultGetSuggestedParams;
-        this.getSigner = params.getSigner;
-        this.defaultValidityWindow = params.defaultValidityWindow ?? this.defaultValidityWindow;
-        this.defaultValidityWindowIsExplicit = params.defaultValidityWindow !== undefined;
-        this.appManager = params.appManager ?? new AppManager(params.algod);
-        this.errorTransformers = params.errorTransformers ?? [];
-    }
-    /**
-     * Register a function that will be used to transform an error caught when simulating or executing
-     *
-     * @returns The composer so you can chain method calls
-     */
-    registerErrorTransformer(transformer) {
-        this.errorTransformers.push(transformer);
-        return this;
-    }
-    /**
-     * Add a pre-built transaction to the transaction group.
-     * @param transaction The pre-built transaction
-     * @param signer Optional signer override for the transaction
-     * @returns The composer so you can chain method calls
-     * @example
-     * ```typescript
-     * composer.addTransaction(txn)
-     * ```
-     */
-    addTransaction(transaction, signer) {
-        this.txns.push({
-            txn: transaction,
-            signer: signer ?? this.getSigner(transaction.sender),
-            type: 'txnWithSigner',
-        });
-        return this;
-    }
-    /**
-     * Add a payment transaction to the transaction group.
-     * @param params The payment transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addPayment({
-     *   sender: 'SENDERADDRESS',
-     *   receiver: 'RECEIVERADDRESS',
-     *   amount: (4).algo(),
-     * })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addPayment({
-     *   amount: (4).algo(),
-     *   receiver: 'RECEIVERADDRESS',
-     *   sender: 'SENDERADDRESS',
-     *   closeRemainderTo: 'CLOSEREMAINDERTOADDRESS',
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
-     *   rekeyTo: 'REKEYTOADDRESS',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     */
-    addPayment(params) {
-        this.txns.push({ ...params, type: 'pay' });
-        return this;
-    }
-    /**
-     * Add an asset create transaction to the transaction group.
-     * @param params The asset create transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAssetCreate({ sender: "CREATORADDRESS", total: 100n})
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAssetCreate({
-     *   sender: 'CREATORADDRESS',
-     *   total: 100n,
-     *   decimals: 2,
-     *   assetName: 'asset',
-     *   unitName: 'unit',
-     *   url: 'url',
-     *   metadataHash: 'metadataHash',
-     *   defaultFrozen: false,
-     *   manager: 'MANAGERADDRESS',
-     *   reserve: 'RESERVEADDRESS',
-     *   freeze: 'FREEZEADDRESS',
-     *   clawback: 'CLAWBACKADDRESS',
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     */
-    addAssetCreate(params) {
-        this.txns.push({ ...params, type: 'assetCreate' });
-        return this;
-    }
-    /**
-     * Add an asset config transaction to the transaction group.
-     * @param params The asset config transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAssetConfig({ sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAssetConfig({
-     *   sender: 'MANAGERADDRESS',
-     *   assetId: 123456n,
-     *   manager: 'MANAGERADDRESS',
-     *   reserve: 'RESERVEADDRESS',
-     *   freeze: 'FREEZEADDRESS',
-     *   clawback: 'CLAWBACKADDRESS',
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     */
-    addAssetConfig(params) {
-        this.txns.push({ ...params, type: 'assetConfig' });
-        return this;
-    }
-    /**
-     * Add an asset freeze transaction to the transaction group.
-     * @param params The asset freeze transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAssetFreeze({ sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAssetFreeze({
-     *   sender: 'MANAGERADDRESS',
-     *   assetId: 123456n,
-     *   account: 'ACCOUNTADDRESS',
-     *   frozen: true,
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     * ```
-     */
-    addAssetFreeze(params) {
-        this.txns.push({ ...params, type: 'assetFreeze' });
-        return this;
-    }
-    /**
-     * Add an asset destroy transaction to the transaction group.
-     * @param params The asset destroy transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAssetDestroy({ sender: "MANAGERADDRESS", assetId: 123456n })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAssetDestroy({
-     *   sender: 'MANAGERADDRESS',
-     *   assetId: 123456n,
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     * ```
-     */
-    addAssetDestroy(params) {
-        this.txns.push({ ...params, type: 'assetDestroy' });
-        return this;
-    }
-    /**
-     * Add an asset transfer transaction to the transaction group.
-     * @param params The asset transfer transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAssetTransfer({ sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
-     * ```
-     * @example Advanced example (with clawback)
-     * ```typescript
-     * composer.addAssetTransfer({
-     *   sender: 'CLAWBACKADDRESS',
-     *   assetId: 123456n,
-     *   amount: 1n,
-     *   receiver: 'RECEIVERADDRESS',
-     *   clawbackTarget: 'HOLDERADDRESS',
-     *   // This field needs to be used with caution
-     *   closeAssetTo: 'ADDRESSTOCLOSETO'
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     * ```
-     */
-    addAssetTransfer(params) {
-        this.txns.push({ ...params, type: 'assetTransfer' });
-        return this;
-    }
-    /**
-     * Add an asset opt-in transaction to the transaction group.
-     * @param params The asset opt-in transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAssetOptIn({ sender: "SENDERADDRESS", assetId: 123456n })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAssetOptIn({
-     *   sender: 'SENDERADDRESS',
-     *   assetId: 123456n,
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     * ```
-     */
-    addAssetOptIn(params) {
-        this.txns.push({ ...params, type: 'assetOptIn' });
-        return this;
-    }
-    /**
-     * Add an asset opt-out transaction to the transaction group.
-     * @param params The asset opt-out transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example (without creator, will be retrieved from algod)
-     * ```typescript
-     * composer.addAssetOptOut({ sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
-     * ```
-     * @example Basic example (with creator)
-     * ```typescript
-     * composer.addAssetOptOut({ sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAssetOptOut({
-     *   sender: 'SENDERADDRESS',
-     *   assetId: 123456n,
-     *   creator: 'CREATORADDRESS',
-     *   ensureZeroBalance: true,
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     * ```
-     */
-    addAssetOptOut(params) {
-        this.txns.push({ ...params, type: 'assetOptOut' });
-        return this;
-    }
-    /**
-     * Add an application create transaction to the transaction group.
-     *
-     * Note: we recommend using app clients to make it easier to make app calls.
-     * @param params The application create transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAppCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAppCreate({
-     *  sender: 'CREATORADDRESS',
-     *  approvalProgram: "TEALCODE",
-     *  clearStateProgram: "TEALCODE",
-     *  schema: {
-     *    globalInts: 1,
-     *    globalByteSlices: 2,
-     *    localInts: 3,
-     *    localByteSlices: 4
-     *  },
-     *  extraProgramPages: 1,
-     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
-     *  args: [new Uint8Array(1, 2, 3, 4)]
-     *  accountReferences: ["ACCOUNT_1"]
-     *  appReferences: [123n, 1234n]
-     *  assetReferences: [12345n]
-     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-     *  accessReferences: [{ appId: 1234n }]
-     *  lease: 'lease',
-     *  note: 'note',
-     *  // You wouldn't normally set this field
-     *  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(),
-     *  rejectVersion: 1,
-     *  // Signer only needed if you want to provide one,
-     *  //  generally you'd register it with AlgorandClient
-     *  //  against the sender and not need to pass it in
-     *  signer: transactionSigner,
-     *  maxRoundsToWaitForConfirmation: 5,
-     *  suppressLog: true,
-     *})
-     * ```
-     */
-    addAppCreate(params) {
-        this.txns.push({ ...params, type: 'appCall' });
-        return this;
-    }
-    /**
-     * Add an application update transaction to the transaction group.
-     *
-     * Note: we recommend using app clients to make it easier to make app calls.
-     * @param params The application update transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAppUpdate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAppUpdate({
-     *  sender: 'CREATORADDRESS',
-     *  approvalProgram: "TEALCODE",
-     *  clearStateProgram: "TEALCODE",
-     *  onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
-     *  args: [new Uint8Array(1, 2, 3, 4)]
-     *  accountReferences: ["ACCOUNT_1"]
-     *  appReferences: [123n, 1234n]
-     *  assetReferences: [12345n]
-     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-     *  accessReferences: [{ appId: 1234n }]
-     *  lease: 'lease',
-     *  note: 'note',
-     *  // You wouldn't normally set this field
-     *  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(),
-     *  rejectVersion: 1,
-     *})
-     * ```
-     */
-    addAppUpdate(params) {
-        this.txns.push({ ...params, type: 'appCall', onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC });
-        return this;
-    }
-    /**
-     * Add an application delete transaction to the transaction group.
-     *
-     * Note: we recommend using app clients to make it easier to make app calls.
-     * @param params The application delete transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAppDelete({ sender: 'CREATORADDRESS' })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAppDelete({
-     *  sender: 'CREATORADDRESS',
-     *  onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC,
-     *  args: [new Uint8Array(1, 2, 3, 4)]
-     *  accountReferences: ["ACCOUNT_1"]
-     *  appReferences: [123n, 1234n]
-     *  assetReferences: [12345n]
-     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-     *  accessReferences: [{ appId: 1234n }]
-     *  lease: 'lease',
-     *  note: 'note',
-     *  // You wouldn't normally set this field
-     *  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(),
-     *  rejectVersion: 1,
-     *})
-     * ```
-     */
-    addAppDelete(params) {
-        this.txns.push({ ...params, type: 'appCall', onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC });
-        return this;
-    }
-    /**
-     * Add an application call transaction to the transaction group.
-     *
-     * If you want to create or update an app use `addAppCreate` or `addAppUpdate`.
-     *
-     * Note: we recommend using app clients to make it easier to make app calls.
-     * @param params The application call transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addAppCall({ sender: 'CREATORADDRESS' })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addAppCall({
-     *  sender: 'CREATORADDRESS',
-     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
-     *  args: [new Uint8Array(1, 2, 3, 4)]
-     *  accountReferences: ["ACCOUNT_1"]
-     *  appReferences: [123n, 1234n]
-     *  assetReferences: [12345n]
-     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-     *  accessReferences: [{ appId: 1234n }]
-     *  lease: 'lease',
-     *  note: 'note',
-     *  // You wouldn't normally set this field
-     *  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(),
-     *  rejectVersion: 1,
-     *})
-     * ```
-     */
-    addAppCall(params) {
-        this.txns.push({ ...params, type: 'appCall' });
-        return this;
-    }
-    /**
-     * Add an ABI method create application call transaction to the transaction group.
-     *
-     * Note: we recommend using app clients to make it easier to make app calls.
-     * @param params The ABI create method application call transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * const method = new ABIMethod({
-     *   name: 'method',
-     *   args: [{ name: 'arg1', type: 'string' }],
-     *   returns: { type: 'string' },
-     * })
-     * composer.addAppCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * const method = new ABIMethod({
-     *   name: 'method',
-     *   args: [{ name: 'arg1', type: 'string' }],
-     *   returns: { type: 'string' },
-     * })
-     * composer.addAppCreateMethodCall({
-     *  sender: 'CREATORADDRESS',
-     *  method: method,
-     *  args: ["arg1_value"],
-     *  approvalProgram: "TEALCODE",
-     *  clearStateProgram: "TEALCODE",
-     *  schema: {
-     *    globalInts: 1,
-     *    globalByteSlices: 2,
-     *    localInts: 3,
-     *    localByteSlices: 4
-     *  },
-     *  extraProgramPages: 1,
-     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
-     *  args: [new Uint8Array(1, 2, 3, 4)]
-     *  accountReferences: ["ACCOUNT_1"]
-     *  appReferences: [123n, 1234n]
-     *  assetReferences: [12345n]
-     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-     *  accessReferences: [{ appId: 1234n }]
-     *  lease: 'lease',
-     *  note: 'note',
-     *  // You wouldn't normally set this field
-     *  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(),
-     *  rejectVersion: 1,
-     *})
-     * ```
-     */
-    addAppCreateMethodCall(params) {
-        this.txns.push({ ...params, type: 'methodCall' });
-        return this;
-    }
-    /**
-     * Add an ABI method update application call transaction to the transaction group.
-     *
-     * Note: we recommend using app clients to make it easier to make app calls.
-     * @param params The ABI update method application call transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * const method = new ABIMethod({
-     *   name: 'method',
-     *   args: [{ name: 'arg1', type: 'string' }],
-     *   returns: { type: 'string' },
-     * })
-     * composer.addAppUpdateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * const method = new ABIMethod({
-     *   name: 'method',
-     *   args: [{ name: 'arg1', type: 'string' }],
-     *   returns: { type: 'string' },
-     * })
-     * composer.addAppUpdateMethodCall({
-     *  sender: 'CREATORADDRESS',
-     *  method: method,
-     *  args: ["arg1_value"],
-     *  approvalProgram: "TEALCODE",
-     *  clearStateProgram: "TEALCODE",
-     *  onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
-     *  args: [new Uint8Array(1, 2, 3, 4)]
-     *  accountReferences: ["ACCOUNT_1"]
-     *  appReferences: [123n, 1234n]
-     *  assetReferences: [12345n]
-     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-     *  accessReferences: [{ appId: 1234n }]
-     *  lease: 'lease',
-     *  note: 'note',
-     *  // You wouldn't normally set this field
-     *  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(),
-     *  rejectVersion: 1,
-     *})
-     * ```
-     */
-    addAppUpdateMethodCall(params) {
-        this.txns.push({ ...params, type: 'methodCall', onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC });
-        return this;
-    }
-    /**
-     * Add an ABI method delete application call transaction to the transaction group.
-     *
-     * Note: we recommend using app clients to make it easier to make app calls.
-     * @param params The ABI delete method application call transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * const method = new ABIMethod({
-     *   name: 'method',
-     *   args: [{ name: 'arg1', type: 'string' }],
-     *   returns: { type: 'string' },
-     * })
-     * composer.addAppDeleteMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * const method = new ABIMethod({
-     *   name: 'method',
-     *   args: [{ name: 'arg1', type: 'string' }],
-     *   returns: { type: 'string' },
-     * })
-     * composer.addAppDeleteMethodCall({
-     *  sender: 'CREATORADDRESS',
-     *  method: method,
-     *  args: ["arg1_value"],
-     *  onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC,
-     *  args: [new Uint8Array(1, 2, 3, 4)]
-     *  accountReferences: ["ACCOUNT_1"]
-     *  appReferences: [123n, 1234n]
-     *  assetReferences: [12345n]
-     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-     *  accessReferences: [{ appId: 1234n }]
-     *  lease: 'lease',
-     *  note: 'note',
-     *  // You wouldn't normally set this field
-     *  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(),
-     *  rejectVersion: 1,
-     *})
-     * ```
-     */
-    addAppDeleteMethodCall(params) {
-        this.txns.push({ ...params, type: 'methodCall', onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC });
-        return this;
-    }
-    /**
-     * Add a non-create/non-update ABI method application call transaction to the transaction group.
-     *
-     * Note: we recommend using app clients to make it easier to make app calls.
-     * @param params The ABI method application call transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * const method = new ABIMethod({
-     *   name: 'method',
-     *   args: [{ name: 'arg1', type: 'string' }],
-     *   returns: { type: 'string' },
-     * })
-     * composer.addAppCallMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * const method = new ABIMethod({
-     *   name: 'method',
-     *   args: [{ name: 'arg1', type: 'string' }],
-     *   returns: { type: 'string' },
-     * })
-     * composer.addAppCallMethodCall({
-     *  sender: 'CREATORADDRESS',
-     *  method: method,
-     *  args: ["arg1_value"],
-     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
-     *  args: [new Uint8Array(1, 2, 3, 4)]
-     *  accountReferences: ["ACCOUNT_1"]
-     *  appReferences: [123n, 1234n]
-     *  assetReferences: [12345n]
-     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-     *  accessReferences: [{ appId: 1234n }]
-     *  lease: 'lease',
-     *  note: 'note',
-     *  // You wouldn't normally set this field
-     *  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(),
-     *  rejectVersion: 1,
-     *})
-     * ```
-     */
-    addAppCallMethodCall(params) {
-        this.txns.push({ ...params, type: 'methodCall' });
-        return this;
-    }
-    /**
-     * Add an online key registration transaction to the transaction group.
-     * @param params The online key registration transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addOnlineKeyRegistration({
-     *   sender: 'SENDERADDRESS',
-     *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
-     *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
-     *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
-     *   voteFirst: 1n,
-     *   voteLast: 1000n,
-     *   voteKeyDilution: 1n,
-     * })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addOnlineKeyRegistration({
-     *   sender: 'SENDERADDRESS',
-     *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
-     *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
-     *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
-     *   voteFirst: 1n,
-     *   voteLast: 1000n,
-     *   voteKeyDilution: 1n,
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
-     *   rekeyTo: 'REKEYTOADDRESS',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     * ```
-     */
-    addOnlineKeyRegistration(params) {
-        this.txns.push({ ...params, type: 'keyReg' });
-        return this;
-    }
-    /**
-     * Add an offline key registration transaction to the transaction group.
-     * @param params The offline key registration transaction parameters
-     * @returns The composer so you can chain method calls
-     * @example Basic example
-     * ```typescript
-     * composer.addOfflineKeyRegistration({
-     *   sender: 'SENDERADDRESS',
-     * })
-     * ```
-     * @example Advanced example
-     * ```typescript
-     * composer.addOfflineKeyRegistration({
-     *   sender: 'SENDERADDRESS',
-     *   lease: 'lease',
-     *   note: 'note',
-     *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
-     *   rekeyTo: 'REKEYTOADDRESS',
-     *   // You wouldn't normally set this field
-     *   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(),
-     * })
-     * ```
-     */
-    addOfflineKeyRegistration(params) {
-        this.txns.push({ ...params, type: 'keyReg' });
-        return this;
-    }
-    /**
-     * Add the transactions within an `AtomicTransactionComposer` to the transaction group.
-     * @param atc The `AtomicTransactionComposer` to build transactions from and add to the group
-     * @returns The composer so you can chain method calls
-     * @example
-     * ```typescript
-     * const atc = new AtomicTransactionComposer()
-     *   .addPayment({ sender: 'SENDERADDRESS', receiver: 'RECEIVERADDRESS', amount: 1000n })
-     * composer.addAtc(atc)
-     * ```
-     */
-    addAtc(atc) {
-        this.txns.push({ atc, type: 'atc' });
-        return this;
-    }
-    /** Build an ATC and return transactions ready to be incorporated into a broader set of transactions this composer is composing */
-    buildAtc(atc) {
-        const group = atc.buildGroup();
-        const txnWithSigners = group.map((ts, idx) => {
-            // Remove underlying group ID from the transaction since it will be re-grouped when this TransactionComposer is built
-            ts.txn.group = undefined;
-            // If this was a method call return the ABIMethod for later
-            if (atc['methodCalls'].get(idx)) {
-                return {
-                    ...ts,
-                    context: { abiMethod: atc['methodCalls'].get(idx) },
-                };
-            }
-            return {
-                ...ts,
-                context: {},
-            };
-        });
-        return txnWithSigners;
-    }
-    commonTxnBuildStep(buildTxn, params, txnParams) {
-        // We are going to mutate suggested params, let's create a clone first
-        txnParams.suggestedParams = { ...txnParams.suggestedParams };
-        if (params.lease)
-            txnParams.lease = encodeLease(params.lease);
-        if (params.rekeyTo)
-            txnParams.rekeyTo = address(params.rekeyTo);
-        const encoder = new TextEncoder();
-        if (params.note)
-            txnParams.note = (typeof params.note === 'string' ? encoder.encode(params.note) : params.note);
-        if (params.firstValidRound) {
-            txnParams.suggestedParams.firstValid = params.firstValidRound;
-        }
-        if (params.lastValidRound) {
-            txnParams.suggestedParams.lastValid = params.lastValidRound;
-        }
-        else {
-            // If the validity window isn't set in this transaction or by default and we are pointing at
-            //  LocalNet set a bigger window to avoid dead transactions
-            const window = params.validityWindow
-                ? BigInt(params.validityWindow)
-                : !this.defaultValidityWindowIsExplicit && genesisIdIsLocalNet(txnParams.suggestedParams.genesisID ?? 'unknown')
-                    ? 1000n
-                    : this.defaultValidityWindow;
-            txnParams.suggestedParams.lastValid = BigInt(txnParams.suggestedParams.firstValid) + window;
-        }
-        if (params.staticFee !== undefined && params.extraFee !== undefined) {
-            throw Error('Cannot set both staticFee and extraFee');
-        }
-        if (params.staticFee !== undefined) {
-            txnParams.suggestedParams.fee = params.staticFee.microAlgo;
-            txnParams.suggestedParams.flatFee = true;
-        }
-        const txn = buildTxn(txnParams);
-        if (params.extraFee)
-            txn.fee += params.extraFee.microAlgo;
-        if (params.maxFee !== undefined && txn.fee > params.maxFee.microAlgo) {
-            throw Error(`Transaction fee ${txn.fee} µALGO is greater than maxFee ${params.maxFee}`);
-        }
-        const logicalMaxFee = params.maxFee !== undefined && params.maxFee.microAlgo > (params.staticFee?.microAlgo ?? 0n) ? params.maxFee : params.staticFee;
-        return { txn, context: { maxFee: logicalMaxFee } };
-    }
-    /**
-     * Builds an ABI method call transaction and any other associated transactions represented in the ABI args.
-     * @param includeSigner Whether to include the actual signer for the transactions.
-     *  If you are just building transactions without signers yet then set this to `false`.
-     */
-    async buildMethodCall(params, suggestedParams, includeSigner) {
-        const methodArgs = [];
-        const transactionsForGroup = [];
-        const isAbiValue = (x) => {
-            if (Array.isArray(x))
-                return x.length == 0 || x.every(isAbiValue);
-            return (typeof x === 'bigint' ||
-                typeof x === 'boolean' ||
-                typeof x === 'number' ||
-                typeof x === 'string' ||
-                x instanceof Uint8Array ||
-                x instanceof algosdk.Address);
-        };
-        for (let i = (params.args ?? []).length - 1; i >= 0; i--) {
-            const arg = params.args[i];
-            if (arg === undefined) {
-                // An undefined transaction argument signals that the value will be supplied by a method call argument
-                if (algosdk.abiTypeIsTransaction(params.method.args[i].type) && transactionsForGroup.length > 0) {
-                    // Move the last transaction from the group to the method call arguments to appease algosdk
-                    const placeholderTransaction = transactionsForGroup.splice(-1, 1)[0];
-                    methodArgs.push(placeholderTransaction);
-                    continue;
-                }
-                throw Error(`No value provided for argument ${i + 1} within call to ${params.method.name}`);
-            }
-            if (isAbiValue(arg)) {
-                methodArgs.push(arg);
-                continue;
-            }
-            if (isTransactionWithSigner(arg)) {
-                methodArgs.push(arg);
-                continue;
-            }
-            if ('method' in arg) {
-                const tempTxnWithSigners = await this.buildMethodCall(arg, suggestedParams, includeSigner);
-                // If there is any transaction args, add to the atc
-                // Everything else should be added as method args
-                methodArgs.push(...tempTxnWithSigners.slice(-1)); // Add the method call itself as a method arg
-                transactionsForGroup.push(...tempTxnWithSigners.slice(0, -1).reverse()); // Add any transaction arguments to the atc
-                continue;
-            }
-            const txn = await arg;
-            methodArgs.push({
-                txn,
-                signer: includeSigner
-                    ? params.signer
-                        ? 'signer' in params.signer
-                            ? params.signer.signer
-                            : params.signer
-                        : this.getSigner(txn.sender)
-                    : TransactionComposer.NULL_SIGNER,
-            });
-        }
-        const methodAtc = new algosdk.AtomicTransactionComposer();
-        const maxFees = new Map();
-        transactionsForGroup.reverse().forEach(({ context, ...txnWithSigner }) => {
-            methodAtc.addTransaction(txnWithSigner);
-            const atcIndex = methodAtc.count() - 1;
-            if (context.abiMethod) {
-                methodAtc['methodCalls'].set(atcIndex, context.abiMethod);
-            }
-            if (context.maxFee !== undefined) {
-                maxFees.set(atcIndex, context.maxFee);
-            }
-        });
-        // If any of the args are method call transactions, add that info to the methodAtc
-        methodArgs
-            .filter((arg) => {
-            if (typeof arg === 'object' && 'context' in arg) {
-                const { context, ...txnWithSigner } = arg;
-                return isTransactionWithSigner(txnWithSigner);
-            }
-            return isTransactionWithSigner(arg);
-        })
-            .reverse()
-            .forEach((arg, idx) => {
-            if (typeof arg === 'object' && 'context' in arg && arg.context) {
-                const atcIndex = methodAtc.count() + idx;
-                if (arg.context.abiMethod) {
-                    methodAtc['methodCalls'].set(atcIndex, arg.context.abiMethod);
-                }
-                if (arg.context.maxFee !== undefined) {
-                    maxFees.set(atcIndex, arg.context.maxFee);
-                }
-            }
-        });
-        const appId = Number('appId' in params ? params.appId : 0n);
-        const approvalProgram = 'approvalProgram' in params
-            ? typeof params.approvalProgram === 'string'
-                ? (await this.appManager.compileTeal(params.approvalProgram)).compiledBase64ToBytes
-                : params.approvalProgram
-            : undefined;
-        const clearStateProgram = 'clearStateProgram' in params
-            ? typeof params.clearStateProgram === 'string'
-                ? (await this.appManager.compileTeal(params.clearStateProgram)).compiledBase64ToBytes
-                : params.clearStateProgram
-            : undefined;
-        const txnParams = {
-            appID: appId,
-            sender: params.sender,
-            suggestedParams,
-            onComplete: params.onComplete ?? algosdk.OnApplicationComplete.NoOpOC,
-            appAccounts: params.accountReferences,
-            appForeignApps: params.appReferences?.map((x) => Number(x)),
-            appForeignAssets: params.assetReferences?.map((x) => Number(x)),
-            boxes: params.boxReferences?.map(AppManager.getBoxReference),
-            access: params.accessReferences?.map(getResourceReference),
-            approvalProgram,
-            clearProgram: clearStateProgram,
-            extraPages: appId === 0
-                ? 'extraProgramPages' in params && params.extraProgramPages !== undefined
-                    ? params.extraProgramPages
-                    : approvalProgram
-                        ? calculateExtraProgramPages(approvalProgram, clearStateProgram)
-                        : 0
-                : undefined,
-            numLocalInts: appId === 0 ? ('schema' in params ? (params.schema?.localInts ?? 0) : 0) : undefined,
-            numLocalByteSlices: appId === 0 ? ('schema' in params ? (params.schema?.localByteSlices ?? 0) : 0) : undefined,
-            numGlobalInts: appId === 0 ? ('schema' in params ? (params.schema?.globalInts ?? 0) : 0) : undefined,
-            numGlobalByteSlices: appId === 0 ? ('schema' in params ? (params.schema?.globalByteSlices ?? 0) : 0) : undefined,
-            method: params.method,
-            signer: includeSigner
-                ? params.signer
-                    ? 'signer' in params.signer
-                        ? params.signer.signer
-                        : params.signer
-                    : this.getSigner(params.sender)
-                : TransactionComposer.NULL_SIGNER,
-            methodArgs: methodArgs
-                .map((arg) => {
-                if (typeof arg === 'object' && 'context' in arg) {
-                    const { context, ...txnWithSigner } = arg;
-                    return txnWithSigner;
-                }
-                return arg;
-            })
-                .reverse(),
-            rejectVersion: params.rejectVersion,
-            // note, lease, and rekeyTo are set in the common build step
-            note: undefined,
-            lease: undefined,
-            rekeyTo: undefined,
-        };
-        // Build the transaction
-        const result = this.commonTxnBuildStep((txnParams) => {
-            methodAtc.addMethodCall(txnParams);
-            return methodAtc.buildGroup()[methodAtc.count() - 1].txn;
-        }, params, txnParams);
-        // Process the ATC to get a set of transactions ready for broader grouping
-        return this.buildAtc(methodAtc).map(({ context: _context, ...txnWithSigner }, idx) => {
-            const maxFee = idx === methodAtc.count() - 1 ? result.context.maxFee : maxFees.get(idx);
-            const context = {
-                ..._context, // Adds method context info
-                maxFee,
-            };
-            return {
-                ...txnWithSigner,
-                context,
-            };
-        });
-    }
-    buildPayment(params, suggestedParams) {
-        return this.commonTxnBuildStep(algosdk.makePaymentTxnWithSuggestedParamsFromObject, params, {
-            sender: params.sender,
-            receiver: params.receiver,
-            amount: params.amount.microAlgo,
-            closeRemainderTo: params.closeRemainderTo,
-            suggestedParams,
-        });
-    }
-    buildAssetCreate(params, suggestedParams) {
-        return this.commonTxnBuildStep(algosdk.makeAssetCreateTxnWithSuggestedParamsFromObject, params, {
-            sender: params.sender,
-            total: params.total,
-            decimals: params.decimals ?? 0,
-            assetName: params.assetName,
-            unitName: params.unitName,
-            assetURL: params.url,
-            defaultFrozen: params.defaultFrozen ?? false,
-            assetMetadataHash: typeof params.metadataHash === 'string' ? Buffer.from(params.metadataHash, 'utf-8') : params.metadataHash,
-            manager: params.manager,
-            reserve: params.reserve,
-            freeze: params.freeze,
-            clawback: params.clawback,
-            suggestedParams,
-        });
-    }
-    buildAssetConfig(params, suggestedParams) {
-        return this.commonTxnBuildStep(algosdk.makeAssetConfigTxnWithSuggestedParamsFromObject, params, {
-            sender: params.sender,
-            assetIndex: params.assetId,
-            suggestedParams,
-            manager: params.manager,
-            reserve: params.reserve,
-            freeze: params.freeze,
-            clawback: params.clawback,
-            strictEmptyAddressChecking: false,
-        });
-    }
-    buildAssetDestroy(params, suggestedParams) {
-        return this.commonTxnBuildStep(algosdk.makeAssetDestroyTxnWithSuggestedParamsFromObject, params, {
-            sender: params.sender,
-            assetIndex: params.assetId,
-            suggestedParams,
-        });
-    }
-    buildAssetFreeze(params, suggestedParams) {
-        return this.commonTxnBuildStep(algosdk.makeAssetFreezeTxnWithSuggestedParamsFromObject, params, {
-            sender: params.sender,
-            assetIndex: params.assetId,
-            freezeTarget: params.account,
-            frozen: params.frozen,
-            suggestedParams,
-        });
-    }
-    buildAssetTransfer(params, suggestedParams) {
-        return this.commonTxnBuildStep(algosdk.makeAssetTransferTxnWithSuggestedParamsFromObject, params, {
-            sender: params.sender,
-            receiver: params.receiver,
-            assetIndex: params.assetId,
-            amount: params.amount,
-            suggestedParams,
-            closeRemainderTo: params.closeAssetTo,
-            assetSender: params.clawbackTarget,
-        });
-    }
-    async buildAppCall(params, suggestedParams) {
-        const appId = 'appId' in params ? params.appId : 0n;
-        const approvalProgram = 'approvalProgram' in params
-            ? typeof params.approvalProgram === 'string'
-                ? (await this.appManager.compileTeal(params.approvalProgram)).compiledBase64ToBytes
-                : params.approvalProgram
-            : undefined;
-        const clearStateProgram = 'clearStateProgram' in params
-            ? typeof params.clearStateProgram === 'string'
-                ? (await this.appManager.compileTeal(params.clearStateProgram)).compiledBase64ToBytes
-                : params.clearStateProgram
-            : undefined;
-        const sdkParams = {
-            sender: params.sender,
-            suggestedParams,
-            appArgs: params.args,
-            onComplete: params.onComplete ?? algosdk.OnApplicationComplete.NoOpOC,
-            accounts: params.accountReferences,
-            foreignApps: params.appReferences?.map((x) => Number(x)),
-            foreignAssets: params.assetReferences?.map((x) => Number(x)),
-            boxes: params.boxReferences?.map(AppManager.getBoxReference),
-            access: params.accessReferences?.map(getResourceReference),
-            approvalProgram,
-            clearProgram: clearStateProgram,
-            rejectVersion: params.rejectVersion,
-        };
-        if (appId === 0n) {
-            if (sdkParams.approvalProgram === undefined || sdkParams.clearProgram === undefined) {
-                throw new Error('approvalProgram and clearStateProgram are required for application creation');
-            }
-            return this.commonTxnBuildStep(algosdk.makeApplicationCreateTxnFromObject, params, {
-                ...sdkParams,
-                extraPages: 'extraProgramPages' in params && params.extraProgramPages !== undefined
-                    ? params.extraProgramPages
-                    : calculateExtraProgramPages(approvalProgram, clearStateProgram),
-                numLocalInts: 'schema' in params ? (params.schema?.localInts ?? 0) : 0,
-                numLocalByteSlices: 'schema' in params ? (params.schema?.localByteSlices ?? 0) : 0,
-                numGlobalInts: 'schema' in params ? (params.schema?.globalInts ?? 0) : 0,
-                numGlobalByteSlices: 'schema' in params ? (params.schema?.globalByteSlices ?? 0) : 0,
-                approvalProgram: approvalProgram,
-                clearProgram: clearStateProgram,
-            });
-        }
-        else {
-            return this.commonTxnBuildStep(algosdk.makeApplicationCallTxnFromObject, params, { ...sdkParams, appIndex: appId });
-        }
-    }
-    buildKeyReg(params, suggestedParams) {
-        if ('voteKey' in params) {
-            return this.commonTxnBuildStep(algosdk.makeKeyRegistrationTxnWithSuggestedParamsFromObject, params, {
-                sender: params.sender,
-                voteKey: params.voteKey,
-                selectionKey: params.selectionKey,
-                voteFirst: params.voteFirst,
-                voteLast: params.voteLast,
-                voteKeyDilution: params.voteKeyDilution,
-                suggestedParams,
-                nonParticipation: false,
-                stateProofKey: params.stateProofKey,
-            });
-        }
-        return this.commonTxnBuildStep(algosdk.makeKeyRegistrationTxnWithSuggestedParamsFromObject, params, {
-            sender: params.sender,
-            suggestedParams,
-            nonParticipation: params.preventAccountFromEverParticipatingAgain,
-        });
-    }
-    /** Builds all transaction types apart from `txnWithSigner`, `atc` and `methodCall` since those ones can have custom signers that need to be retrieved. */
-    async buildTxn(txn, suggestedParams) {
-        switch (txn.type) {
-            case 'pay':
-                return [this.buildPayment(txn, suggestedParams)];
-            case 'assetCreate':
-                return [this.buildAssetCreate(txn, suggestedParams)];
-            case 'appCall':
-                return [await this.buildAppCall(txn, suggestedParams)];
-            case 'assetConfig':
-                return [this.buildAssetConfig(txn, suggestedParams)];
-            case 'assetDestroy':
-                return [this.buildAssetDestroy(txn, suggestedParams)];
-            case 'assetFreeze':
-                return [this.buildAssetFreeze(txn, suggestedParams)];
-            case 'assetTransfer':
-                return [this.buildAssetTransfer(txn, suggestedParams)];
-            case 'assetOptIn':
-                return [this.buildAssetTransfer({ ...txn, receiver: txn.sender, amount: 0n }, suggestedParams)];
-            case 'assetOptOut':
-                return [this.buildAssetTransfer({ ...txn, receiver: txn.sender, amount: 0n, closeAssetTo: txn.creator }, suggestedParams)];
-            case 'keyReg':
-                return [this.buildKeyReg(txn, suggestedParams)];
-            default:
-                throw Error(`Unsupported txn type`);
-        }
-    }
-    async buildTxnWithSigner(txn, suggestedParams) {
-        if (txn.type === 'txnWithSigner') {
-            return [
-                {
-                    ...txn,
-                    context: {},
-                },
-            ];
-        }
-        if (txn.type === 'atc') {
-            return this.buildAtc(txn.atc);
-        }
-        if (txn.type === 'methodCall') {
-            return await this.buildMethodCall(txn, suggestedParams, true);
-        }
-        const signer = txn.signer ? ('signer' in txn.signer ? txn.signer.signer : txn.signer) : this.getSigner(txn.sender);
-        return (await this.buildTxn(txn, suggestedParams)).map(({ txn, context }) => ({ txn, signer, context }));
-    }
-    /**
-     * Compose all of the transactions without signers and return the transaction objects directly along with any ABI method calls.
-     *
-     * @returns The array of built transactions and any corresponding method calls
-     * @example
-     * ```typescript
-     * const { transactions, methodCalls, signers } = await composer.buildTransactions()
-     * ```
-     */
-    async buildTransactions() {
-        const suggestedParams = await this.getSuggestedParams();
-        const transactions = [];
-        const methodCalls = new Map();
-        const signers = new Map();
-        for (const txn of this.txns) {
-            if (!['txnWithSigner', 'atc', 'methodCall'].includes(txn.type)) {
-                transactions.push(...(await this.buildTxn(txn, suggestedParams)).map((txn) => txn.txn));
-            }
-            else {
-                const transactionsWithSigner = txn.type === 'txnWithSigner'
-                    ? [txn]
-                    : txn.type === 'atc'
-                        ? this.buildAtc(txn.atc)
-                        : txn.type === 'methodCall'
-                            ? await this.buildMethodCall(txn, suggestedParams, false)
-                            : [];
-                transactionsWithSigner.forEach((ts) => {
-                    transactions.push(ts.txn);
-                    const groupIdx = transactions.length - 1;
-                    if (ts.signer && ts.signer !== TransactionComposer.NULL_SIGNER) {
-                        signers.set(groupIdx, ts.signer);
-                    }
-                    if ('context' in ts && ts.context.abiMethod) {
-                        methodCalls.set(groupIdx, ts.context.abiMethod);
-                    }
-                });
-            }
-        }
-        return { transactions, methodCalls, signers };
-    }
-    /**
-     * Get the number of transactions currently added to this composer.
-     * @returns The number of transactions currently added to this composer
-     */
-    async count() {
-        return (await this.buildTransactions()).transactions.length;
-    }
-    /**
-     * Compose all of the transactions in a single atomic transaction group and an atomic transaction composer.
-     *
-     * You can then use the transactions standalone, or use the composer to execute or simulate the transactions.
-     *
-     * Once this method is called, no further transactions will be able to be added.
-     * You can safely call this method multiple times to get the same result.
-     * @returns The built atomic transaction composer, the transactions and any corresponding method calls
-     * @example
-     * ```typescript
-     * const { atc, transactions, methodCalls } = await composer.build()
-     * ```
-     */
-    async build() {
-        if (this.atc.getStatus() === algosdk.AtomicTransactionComposerStatus.BUILDING) {
-            const suggestedParams = await this.getSuggestedParams();
-            // Build all of the transactions
-            const txnWithSigners = [];
-            for (const txn of this.txns) {
-                txnWithSigners.push(...(await this.buildTxnWithSigner(txn, suggestedParams)));
-            }
-            // Add all of the transactions to the underlying ATC
-            const methodCalls = new Map();
-            txnWithSigners.forEach(({ context, ...ts }, idx) => {
-                this.atc.addTransaction(ts);
-                // Populate consolidated set of all ABI method calls
-                if (context.abiMethod) {
-                    methodCalls.set(idx, context.abiMethod);
-                }
-                if (context.maxFee !== undefined) {
-                    this.txnMaxFees.set(idx, context.maxFee);
-                }
-            });
-            this.atc['methodCalls'] = methodCalls;
-        }
-        const transactions = this.atc.buildGroup();
-        return { atc: this.atc, transactions, methodCalls: this.atc['methodCalls'] };
-    }
-    /**
-     * Rebuild the group, discarding any previously built transactions.
-     * This will potentially cause new signers and suggested params to be used if the callbacks return a new value compared to the first build.
-     * @returns The newly built atomic transaction composer and the transactions
-     * @example
-     * ```typescript
-     * const { atc, transactions, methodCalls } = await composer.rebuild()
-     * ```
-     */
-    async rebuild() {
-        this.atc = new algosdk.AtomicTransactionComposer();
-        return await this.build();
-    }
-    /**
-     * Compose the atomic transaction group and send it to the network.
-     * @param params The parameters to control execution with
-     * @returns The execution result
-     * @example
-     * ```typescript
-     * const result = await composer.send()
-     * ```
-     */
-    async send(params) {
-        const group = (await this.build()).transactions;
-        let waitRounds = params?.maxRoundsToWaitForConfirmation;
-        const suggestedParams = waitRounds === undefined || params?.coverAppCallInnerTransactionFees ? await this.getSuggestedParams() : undefined;
-        if (waitRounds === undefined) {
-            const lastRound = group.reduce((max, txn) => (txn.txn.lastValid > max ? txn.txn.lastValid : BigInt(max)), 0n);
-            const { firstValid: firstRound } = suggestedParams;
-            waitRounds = Number(BigInt(lastRound) - BigInt(firstRound)) + 1;
-        }
-        try {
-            return await sendAtomicTransactionComposer({
-                atc: this.atc,
-                suppressLog: params?.suppressLog,
-                maxRoundsToWaitForConfirmation: waitRounds,
-                populateAppCallResources: params?.populateAppCallResources,
-                coverAppCallInnerTransactionFees: params?.coverAppCallInnerTransactionFees,
-                additionalAtcContext: params?.coverAppCallInnerTransactionFees
-                    ? {
-                        maxFees: this.txnMaxFees,
-                        suggestedParams: suggestedParams,
-                    }
-                    : undefined,
-            }, this.algod);
-        }
-        catch (originalError) {
-            throw await this.transformError(originalError);
-        }
-    }
-    /**
-     * @deprecated Use `send` instead.
-     *
-     * Compose the atomic transaction group and send it to the network
-     *
-     * An alias for `composer.send(params)`.
-     * @param params The parameters to control execution with
-     * @returns The execution result
-     */
-    async execute(params) {
-        return this.send(params);
-    }
-    async simulate(options) {
-        const { skipSignatures = false, ...rawOptions } = options ?? {};
-        const atc = skipSignatures ? new AtomicTransactionComposer() : this.atc;
-        // Build the transactions
-        if (skipSignatures) {
-            rawOptions.allowEmptySignatures = true;
-            rawOptions.fixSigners = true;
-            // Build transactions uses empty signers
-            const transactions = await this.buildTransactions();
-            for (const txn of transactions.transactions) {
-                atc.addTransaction({ txn, signer: TransactionComposer.NULL_SIGNER });
-            }
-            atc['methodCalls'] = transactions.methodCalls;
-        }
-        else {
-            // Build creates real signatures
-            await this.build();
-        }
-        const { methodResults, simulateResponse } = await atc.simulate(this.algod, new modelsv2.SimulateRequest({
-            txnGroups: [],
-            ...rawOptions,
-            ...(Config.debug
-                ? {
-                    allowEmptySignatures: true,
-                    fixSigners: true,
-                    allowMoreLogging: true,
-                    execTraceConfig: new modelsv2.SimulateTraceConfig({
-                        enable: true,
-                        scratchChange: true,
-                        stackChange: true,
-                        stateChange: true,
-                    }),
-                }
-                : undefined),
-        }));
-        const failedGroup = simulateResponse?.txnGroups[0];
-        if (failedGroup?.failureMessage) {
-            const errorMessage = `Transaction failed at transaction(s) ${failedGroup.failedAt?.join(', ') || 'unknown'} in the group. ${failedGroup.failureMessage}`;
-            const error = new Error(errorMessage);
-            if (Config.debug) {
-                await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateResponse });
-            }
-            throw await this.transformError(error);
-        }
-        if (Config.debug && Config.traceAll) {
-            await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateResponse });
-        }
-        const transactions = atc.buildGroup().map((t) => t.txn);
-        const methodCalls = [...atc['methodCalls'].values()];
-        return {
-            confirmations: simulateResponse.txnGroups[0].txnResults.map((t) => t.txnResult),
-            transactions: transactions,
-            txIds: transactions.map((t) => t.txID()),
-            groupId: Buffer.from(transactions[0].group ?? new Uint8Array()).toString('base64'),
-            simulateResponse,
-            returns: methodResults.map((r, i) => getABIReturnValue(r, methodCalls[i].returns.type)),
-        };
-    }
-    /**
-     * Create an encoded transaction note that follows the ARC-2 spec.
-     *
-     * https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md
-     * @param note The ARC-2 transaction note data
-     * @returns The binary encoded transaction note
-     */
-    static arc2Note(note) {
-        const arc2Payload = `${note.dAppName}:${note.format}${typeof note.data === 'string' ? note.data : asJson(note.data)}`;
-        const encoder = new TextEncoder();
-        return encoder.encode(arc2Payload);
-    }
-}
-/** Signer used to represent a lack of signer */
-TransactionComposer.NULL_SIGNER = algosdk.makeEmptyTransactionSigner();
-/**
- * Returns an `algosdk.TransactionResourceReference` given a `ResourceReference`.
- */
-function getResourceReference(accessReference) {
-    return {
-        address: typeof accessReference.address === 'string' ? Address.fromString(accessReference.address) : accessReference.address,
-        appIndex: accessReference.appId,
-        assetIndex: accessReference.assetId,
-        holding: accessReference.holding ? getHoldingReference(accessReference.holding) : undefined,
-        locals: accessReference.locals ? getLocalsReference(accessReference.locals) : undefined,
-        box: accessReference.box ? AppManager.getBoxReference(accessReference.box) : undefined,
-    };
-}
-function getHoldingReference(holdingReference) {
-    return {
-        assetIndex: holdingReference.assetId,
-        address: typeof holdingReference.address === 'string' ? Address.fromString(holdingReference.address) : holdingReference.address,
-    };
-}
-function getLocalsReference(localsReference) {
-    return {
-        appIndex: localsReference.appId,
-        address: typeof localsReference.address === 'string' ? Address.fromString(localsReference.address) : localsReference.address,
-    };
+var TransactionComposer = class TransactionComposer {
+	/** Transactions that have not yet been composed */
+	txns = [];
+	/** The algod client used by the composer. */
+	algod;
+	/** An async function that will return suggested params for the transaction. */
+	getSuggestedParams;
+	/** A function that takes in an address and return a signer function for that address. */
+	getSigner;
+	/** The default transaction validity window */
+	defaultValidityWindow = 10n;
+	/** Whether the validity window was explicitly set on construction */
+	defaultValidityWindowIsExplicit = false;
+	appManager;
+	errorTransformers;
+	composerConfig;
+	transactionsWithSigners;
+	signedTransactions;
+	rawBuildTransactions;
+	async transformError(originalError) {
+		if (!(originalError instanceof Error)) return originalError;
+		let transformedError = originalError;
+		for (const transformer of this.errorTransformers) try {
+			transformedError = await transformer(transformedError);
+			if (!(transformedError instanceof Error)) return new InvalidErrorTransformerValue(originalError, transformedError);
+		} catch (errorFromTransformer) {
+			return new ErrorTransformerError(originalError, errorFromTransformer);
+		}
+		return transformedError;
+	}
+	validateReferenceParams(params) {
+		if (params.accessReferences && params.accessReferences.length > 0 && (params.appReferences && params.appReferences.length > 0 || params.assetReferences && params.assetReferences.length > 0 || params.boxReferences && params.boxReferences.length > 0)) throw new Error("Cannot specify both `accessReferences` and reference arrays (`appReferences`, `assetReferences`, `boxReferences`).");
+	}
+	/**
+	* Create a `TransactionComposer`.
+	* @param params The configuration for this composer
+	* @returns The `TransactionComposer` instance
+	*/
+	constructor(params) {
+		this.algod = params.algod;
+		const defaultGetSuggestedParams = () => params.algod.suggestedParams();
+		this.getSuggestedParams = params.getSuggestedParams ?? defaultGetSuggestedParams;
+		this.getSigner = params.getSigner;
+		this.defaultValidityWindow = params.defaultValidityWindow ?? this.defaultValidityWindow;
+		this.defaultValidityWindowIsExplicit = params.defaultValidityWindow !== void 0;
+		this.appManager = params.appManager ?? new AppManager(params.algod);
+		this.errorTransformers = params.errorTransformers ?? [];
+		this.composerConfig = params.composerConfig ?? {
+			coverAppCallInnerTransactionFees: false,
+			populateAppCallResources: true
+		};
+	}
+	cloneTransaction(txn) {
+		switch (txn.type) {
+			case "pay": return {
+				type: "pay",
+				data: { ...txn.data }
+			};
+			case "assetCreate": return {
+				type: "assetCreate",
+				data: { ...txn.data }
+			};
+			case "assetConfig": return {
+				type: "assetConfig",
+				data: { ...txn.data }
+			};
+			case "assetFreeze": return {
+				type: "assetFreeze",
+				data: { ...txn.data }
+			};
+			case "assetDestroy": return {
+				type: "assetDestroy",
+				data: { ...txn.data }
+			};
+			case "assetTransfer": return {
+				type: "assetTransfer",
+				data: { ...txn.data }
+			};
+			case "assetOptIn": return {
+				type: "assetOptIn",
+				data: { ...txn.data }
+			};
+			case "assetOptOut": return {
+				type: "assetOptOut",
+				data: { ...txn.data }
+			};
+			case "appCall": return {
+				type: "appCall",
+				data: { ...txn.data }
+			};
+			case "keyReg": return {
+				type: "keyReg",
+				data: { ...txn.data }
+			};
+			case "txn": {
+				const { txn: transaction, signer, maxFee } = txn.data;
+				const clonedTxn = decodeTransaction(encodeTransactionRaw(transaction));
+				delete clonedTxn.group;
+				return {
+					type: "txn",
+					data: {
+						txn: clonedTxn,
+						signer,
+						maxFee
+					}
+				};
+			}
+			case "asyncTxn": {
+				const { txn: txnPromise, signer, maxFee } = txn.data;
+				return {
+					type: "asyncTxn",
+					data: {
+						txn: txnPromise.then((resolvedTxn) => {
+							const clonedTxn = decodeTransaction(encodeTransactionRaw(resolvedTxn));
+							delete clonedTxn.group;
+							return clonedTxn;
+						}),
+						signer,
+						maxFee
+					}
+				};
+			}
+			case "methodCall": return {
+				type: "methodCall",
+				data: { ...txn.data }
+			};
+		}
+	}
+	push(...txns) {
+		if (this.transactionsWithSigners) throw new Error("Cannot add new transactions after building");
+		if (this.txns.length + txns.length > MAX_TRANSACTION_GROUP_SIZE) throw new Error(`Adding ${txns.length} transaction(s) would exceed the maximum group size. Current: ${this.txns.length}, Maximum: ${MAX_TRANSACTION_GROUP_SIZE}`);
+		this.txns.push(...txns);
+	}
+	clone(composerConfig) {
+		const newComposer = new TransactionComposer({
+			algod: this.algod,
+			getSuggestedParams: this.getSuggestedParams,
+			getSigner: this.getSigner,
+			defaultValidityWindow: this.defaultValidityWindow,
+			appManager: this.appManager,
+			errorTransformers: this.errorTransformers,
+			composerConfig: {
+				...this.composerConfig,
+				...composerConfig
+			}
+		});
+		this.txns.forEach((txn) => {
+			newComposer.txns.push(this.cloneTransaction(txn));
+		});
+		newComposer.defaultValidityWindowIsExplicit = this.defaultValidityWindowIsExplicit;
+		return newComposer;
+	}
+	/**
+	* Register a function that will be used to transform an error caught when simulating or executing
+	*
+	* @returns The composer so you can chain method calls
+	*/
+	registerErrorTransformer(transformer) {
+		this.errorTransformers.push(transformer);
+		return this;
+	}
+	/**
+	* Add a pre-built transaction to the transaction group.
+	* @param transaction The pre-built transaction
+	* @param signer Optional signer override for the transaction
+	* @returns The composer so you can chain method calls
+	* @example
+	* ```typescript
+	* composer.addTransaction(txn)
+	* ```
+	*/
+	addTransaction(transaction, signer) {
+		if (transaction.group) throw new Error("Cannot add a transaction to the composer because it is already in a group");
+		this.push({
+			data: {
+				txn: transaction,
+				signer: signer ?? this.getSigner(transaction.sender)
+			},
+			type: "txn"
+		});
+		return this;
+	}
+	/**
+	* Add another transaction composer to the current transaction composer.
+	* The transaction params of the input transaction composer will be added.
+	* If the input transaction composer is updated, it won't affect the current transaction composer.
+	* @param composer The transaction composer to add
+	* @returns The composer so you can chain method calls
+	* @example
+	* ```typescript
+	* const innerComposer = algorand.newGroup()
+	*   .addPayment({ sender: 'SENDER', receiver: 'RECEIVER', amount: (1).algo() })
+	*   .addPayment({ sender: 'SENDER', receiver: 'RECEIVER', amount: (2).algo() })
+	*
+	* composer.addTransactionComposer(innerComposer)
+	* ```
+	*/
+	addTransactionComposer(composer) {
+		const clonedTxns = composer.txns.map((txn) => this.cloneTransaction(txn));
+		this.push(...clonedTxns);
+		return this;
+	}
+	/**
+	* Add a payment transaction to the transaction group.
+	* @param params The payment transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addPayment({
+	*   sender: 'SENDERADDRESS',
+	*   receiver: 'RECEIVERADDRESS',
+	*   amount: (4).algo(),
+	* })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addPayment({
+	*   amount: (4).algo(),
+	*   receiver: 'RECEIVERADDRESS',
+	*   sender: 'SENDERADDRESS',
+	*   closeRemainderTo: 'CLOSEREMAINDERTOADDRESS',
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+	*   rekeyTo: 'REKEYTOADDRESS',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	*/
+	addPayment(params) {
+		this.push({
+			data: params,
+			type: "pay"
+		});
+		return this;
+	}
+	/**
+	* Add an asset create transaction to the transaction group.
+	* @param params The asset create transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAssetCreate({ sender: "CREATORADDRESS", total: 100n})
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAssetCreate({
+	*   sender: 'CREATORADDRESS',
+	*   total: 100n,
+	*   decimals: 2,
+	*   assetName: 'asset',
+	*   unitName: 'unit',
+	*   url: 'url',
+	*   metadataHash: 'metadataHash',
+	*   defaultFrozen: false,
+	*   manager: 'MANAGERADDRESS',
+	*   reserve: 'RESERVEADDRESS',
+	*   freeze: 'FREEZEADDRESS',
+	*   clawback: 'CLAWBACKADDRESS',
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	*/
+	addAssetCreate(params) {
+		this.push({
+			data: params,
+			type: "assetCreate"
+		});
+		return this;
+	}
+	/**
+	* Add an asset config transaction to the transaction group.
+	* @param params The asset config transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAssetConfig({ sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAssetConfig({
+	*   sender: 'MANAGERADDRESS',
+	*   assetId: 123456n,
+	*   manager: 'MANAGERADDRESS',
+	*   reserve: 'RESERVEADDRESS',
+	*   freeze: 'FREEZEADDRESS',
+	*   clawback: 'CLAWBACKADDRESS',
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	*/
+	addAssetConfig(params) {
+		this.push({
+			data: params,
+			type: "assetConfig"
+		});
+		return this;
+	}
+	/**
+	* Add an asset freeze transaction to the transaction group.
+	* @param params The asset freeze transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAssetFreeze({ sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAssetFreeze({
+	*   sender: 'MANAGERADDRESS',
+	*   assetId: 123456n,
+	*   account: 'ACCOUNTADDRESS',
+	*   frozen: true,
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	* ```
+	*/
+	addAssetFreeze(params) {
+		this.push({
+			data: params,
+			type: "assetFreeze"
+		});
+		return this;
+	}
+	/**
+	* Add an asset destroy transaction to the transaction group.
+	* @param params The asset destroy transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAssetDestroy({ sender: "MANAGERADDRESS", assetId: 123456n })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAssetDestroy({
+	*   sender: 'MANAGERADDRESS',
+	*   assetId: 123456n,
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	* ```
+	*/
+	addAssetDestroy(params) {
+		this.push({
+			data: params,
+			type: "assetDestroy"
+		});
+		return this;
+	}
+	/**
+	* Add an asset transfer transaction to the transaction group.
+	* @param params The asset transfer transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAssetTransfer({ sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+	* ```
+	* @example Advanced example (with clawback)
+	* ```typescript
+	* composer.addAssetTransfer({
+	*   sender: 'CLAWBACKADDRESS',
+	*   assetId: 123456n,
+	*   amount: 1n,
+	*   receiver: 'RECEIVERADDRESS',
+	*   clawbackTarget: 'HOLDERADDRESS',
+	*   // This field needs to be used with caution
+	*   closeAssetTo: 'ADDRESSTOCLOSETO'
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	* ```
+	*/
+	addAssetTransfer(params) {
+		this.push({
+			data: params,
+			type: "assetTransfer"
+		});
+		return this;
+	}
+	/**
+	* Add an asset opt-in transaction to the transaction group.
+	* @param params The asset opt-in transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAssetOptIn({ sender: "SENDERADDRESS", assetId: 123456n })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAssetOptIn({
+	*   sender: 'SENDERADDRESS',
+	*   assetId: 123456n,
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	* ```
+	*/
+	addAssetOptIn(params) {
+		this.push({
+			data: params,
+			type: "assetOptIn"
+		});
+		return this;
+	}
+	/**
+	* Add an asset opt-out transaction to the transaction group.
+	* @param params The asset opt-out transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example (without creator, will be retrieved from algod)
+	* ```typescript
+	* composer.addAssetOptOut({ sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
+	* ```
+	* @example Basic example (with creator)
+	* ```typescript
+	* composer.addAssetOptOut({ sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAssetOptOut({
+	*   sender: 'SENDERADDRESS',
+	*   assetId: 123456n,
+	*   creator: 'CREATORADDRESS',
+	*   ensureZeroBalance: true,
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	* ```
+	*/
+	addAssetOptOut(params) {
+		this.push({
+			data: params,
+			type: "assetOptOut"
+		});
+		return this;
+	}
+	/**
+	* Add an application create transaction to the transaction group.
+	*
+	* Note: we recommend using app clients to make it easier to make app calls.
+	* @param params The application create transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAppCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAppCreate({
+	*  sender: 'CREATORADDRESS',
+	*  approvalProgram: "TEALCODE",
+	*  clearStateProgram: "TEALCODE",
+	*  schema: {
+	*    globalInts: 1,
+	*    globalByteSlices: 2,
+	*    localInts: 3,
+	*    localByteSlices: 4
+	*  },
+	*  extraProgramPages: 1,
+	*  onComplete: OnApplicationComplete.OptIn,
+	*  args: [new Uint8Array(1, 2, 3, 4)]
+	*  accountReferences: ["ACCOUNT_1"]
+	*  appReferences: [123n, 1234n]
+	*  assetReferences: [12345n]
+	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+	*  accessReferences: [{ appId: 1234n }]
+	*  lease: 'lease',
+	*  note: 'note',
+	*  // You wouldn't normally set this field
+	*  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(),
+	*  rejectVersion: 1,
+	*  // Signer only needed if you want to provide one,
+	*  //  generally you'd register it with AlgorandClient
+	*  //  against the sender and not need to pass it in
+	*  signer: transactionSigner,
+	*  maxRoundsToWaitForConfirmation: 5,
+	*  suppressLog: true,
+	*})
+	* ```
+	*/
+	addAppCreate(params) {
+		this.validateReferenceParams(params);
+		this.push({
+			data: params,
+			type: "appCall"
+		});
+		return this;
+	}
+	/**
+	* Add an application update transaction to the transaction group.
+	*
+	* Note: we recommend using app clients to make it easier to make app calls.
+	* @param params The application update transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAppUpdate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAppUpdate({
+	*  sender: 'CREATORADDRESS',
+	*  approvalProgram: "TEALCODE",
+	*  clearStateProgram: "TEALCODE",
+	*  onComplete: OnApplicationComplete.UpdateApplication,
+	*  args: [new Uint8Array(1, 2, 3, 4)]
+	*  accountReferences: ["ACCOUNT_1"]
+	*  appReferences: [123n, 1234n]
+	*  assetReferences: [12345n]
+	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+	*  accessReferences: [{ appId: 1234n }]
+	*  lease: 'lease',
+	*  note: 'note',
+	*  // You wouldn't normally set this field
+	*  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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppUpdate(params) {
+		this.validateReferenceParams(params);
+		this.push({
+			data: {
+				...params,
+				onComplete: OnApplicationComplete.UpdateApplication
+			},
+			type: "appCall"
+		});
+		return this;
+	}
+	/**
+	* Add an application delete transaction to the transaction group.
+	*
+	* Note: we recommend using app clients to make it easier to make app calls.
+	* @param params The application delete transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAppDelete({ sender: 'CREATORADDRESS' })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAppDelete({
+	*  sender: 'CREATORADDRESS',
+	*  onComplete: OnApplicationComplete.DeleteApplication,
+	*  args: [new Uint8Array(1, 2, 3, 4)]
+	*  accountReferences: ["ACCOUNT_1"]
+	*  appReferences: [123n, 1234n]
+	*  assetReferences: [12345n]
+	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+	*  accessReferences: [{ appId: 1234n }]
+	*  lease: 'lease',
+	*  note: 'note',
+	*  // You wouldn't normally set this field
+	*  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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppDelete(params) {
+		this.validateReferenceParams(params);
+		this.push({
+			data: {
+				...params,
+				onComplete: OnApplicationComplete.DeleteApplication
+			},
+			type: "appCall"
+		});
+		return this;
+	}
+	/**
+	* Add an application call transaction to the transaction group.
+	*
+	* If you want to create or update an app use `addAppCreate` or `addAppUpdate`.
+	*
+	* Note: we recommend using app clients to make it easier to make app calls.
+	* @param params The application call transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addAppCall({ sender: 'CREATORADDRESS' })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addAppCall({
+	*  sender: 'CREATORADDRESS',
+	*  onComplete: OnApplicationComplete.OptIn,
+	*  args: [new Uint8Array(1, 2, 3, 4)]
+	*  accountReferences: ["ACCOUNT_1"]
+	*  appReferences: [123n, 1234n]
+	*  assetReferences: [12345n]
+	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+	*  accessReferences: [{ appId: 1234n }]
+	*  lease: 'lease',
+	*  note: 'note',
+	*  // You wouldn't normally set this field
+	*  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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppCall(params) {
+		this.validateReferenceParams(params);
+		this.push({
+			data: params,
+			type: "appCall"
+		});
+		return this;
+	}
+	/**
+	* Add an ABI method create application call transaction to the transaction group.
+	*
+	* Note: we recommend using app clients to make it easier to make app calls.
+	* @param params The ABI create method application call transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* const method = new ABIMethod({
+	*   name: 'method',
+	*   args: [{ name: 'arg1', type: 'string' }],
+	*   returns: { type: 'string' },
+	* })
+	* composer.addAppCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* const method = new ABIMethod({
+	*   name: 'method',
+	*   args: [{ name: 'arg1', type: 'string' }],
+	*   returns: { type: 'string' },
+	* })
+	* composer.addAppCreateMethodCall({
+	*  sender: 'CREATORADDRESS',
+	*  method: method,
+	*  args: ["arg1_value"],
+	*  approvalProgram: "TEALCODE",
+	*  clearStateProgram: "TEALCODE",
+	*  schema: {
+	*    globalInts: 1,
+	*    globalByteSlices: 2,
+	*    localInts: 3,
+	*    localByteSlices: 4
+	*  },
+	*  extraProgramPages: 1,
+	*  onComplete: OnApplicationComplete.OptIn,
+	*  args: [new Uint8Array(1, 2, 3, 4)]
+	*  accountReferences: ["ACCOUNT_1"]
+	*  appReferences: [123n, 1234n]
+	*  assetReferences: [12345n]
+	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+	*  accessReferences: [{ appId: 1234n }]
+	*  lease: 'lease',
+	*  note: 'note',
+	*  // You wouldn't normally set this field
+	*  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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppCreateMethodCall(params) {
+		this.validateReferenceParams(params);
+		const txnArgs = extractComposerTransactionsFromAppMethodCallParams(params);
+		this.push(...txnArgs, {
+			data: {
+				...params,
+				args: processAppMethodCallArgs(params.args)
+			},
+			type: "methodCall"
+		});
+		return this;
+	}
+	/**
+	* Add an ABI method update application call transaction to the transaction group.
+	*
+	* Note: we recommend using app clients to make it easier to make app calls.
+	* @param params The ABI update method application call transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* const method = new ABIMethod({
+	*   name: 'method',
+	*   args: [{ name: 'arg1', type: 'string' }],
+	*   returns: { type: 'string' },
+	* })
+	* composer.addAppUpdateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* const method = new ABIMethod({
+	*   name: 'method',
+	*   args: [{ name: 'arg1', type: 'string' }],
+	*   returns: { type: 'string' },
+	* })
+	* composer.addAppUpdateMethodCall({
+	*  sender: 'CREATORADDRESS',
+	*  method: method,
+	*  args: ["arg1_value"],
+	*  approvalProgram: "TEALCODE",
+	*  clearStateProgram: "TEALCODE",
+	*  onComplete: OnApplicationComplete.UpdateApplication,
+	*  args: [new Uint8Array(1, 2, 3, 4)]
+	*  accountReferences: ["ACCOUNT_1"]
+	*  appReferences: [123n, 1234n]
+	*  assetReferences: [12345n]
+	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+	*  accessReferences: [{ appId: 1234n }]
+	*  lease: 'lease',
+	*  note: 'note',
+	*  // You wouldn't normally set this field
+	*  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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppUpdateMethodCall(params) {
+		this.validateReferenceParams(params);
+		const txnArgs = extractComposerTransactionsFromAppMethodCallParams(params);
+		this.push(...txnArgs, {
+			data: {
+				...params,
+				args: processAppMethodCallArgs(params.args),
+				onComplete: OnApplicationComplete.UpdateApplication
+			},
+			type: "methodCall"
+		});
+		return this;
+	}
+	/**
+	* Add an ABI method delete application call transaction to the transaction group.
+	*
+	* Note: we recommend using app clients to make it easier to make app calls.
+	* @param params The ABI delete method application call transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* const method = new ABIMethod({
+	*   name: 'method',
+	*   args: [{ name: 'arg1', type: 'string' }],
+	*   returns: { type: 'string' },
+	* })
+	* composer.addAppDeleteMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* const method = new ABIMethod({
+	*   name: 'method',
+	*   args: [{ name: 'arg1', type: 'string' }],
+	*   returns: { type: 'string' },
+	* })
+	* composer.addAppDeleteMethodCall({
+	*  sender: 'CREATORADDRESS',
+	*  method: method,
+	*  args: ["arg1_value"],
+	*  onComplete: OnApplicationComplete.DeleteApplication,
+	*  args: [new Uint8Array(1, 2, 3, 4)]
+	*  accountReferences: ["ACCOUNT_1"]
+	*  appReferences: [123n, 1234n]
+	*  assetReferences: [12345n]
+	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+	*  accessReferences: [{ appId: 1234n }]
+	*  lease: 'lease',
+	*  note: 'note',
+	*  // You wouldn't normally set this field
+	*  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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppDeleteMethodCall(params) {
+		this.validateReferenceParams(params);
+		const txnArgs = extractComposerTransactionsFromAppMethodCallParams(params);
+		this.push(...txnArgs, {
+			data: {
+				...params,
+				args: processAppMethodCallArgs(params.args),
+				onComplete: OnApplicationComplete.DeleteApplication
+			},
+			type: "methodCall"
+		});
+		return this;
+	}
+	/**
+	* Add a non-create/non-update ABI method application call transaction to the transaction group.
+	*
+	* Note: we recommend using app clients to make it easier to make app calls.
+	* @param params The ABI method application call transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* const method = new ABIMethod({
+	*   name: 'method',
+	*   args: [{ name: 'arg1', type: 'string' }],
+	*   returns: { type: 'string' },
+	* })
+	* composer.addAppCallMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* const method = new ABIMethod({
+	*   name: 'method',
+	*   args: [{ name: 'arg1', type: 'string' }],
+	*   returns: { type: 'string' },
+	* })
+	* composer.addAppCallMethodCall({
+	*  sender: 'CREATORADDRESS',
+	*  method: method,
+	*  args: ["arg1_value"],
+	*  onComplete: OnApplicationComplete.OptIn,
+	*  args: [new Uint8Array(1, 2, 3, 4)]
+	*  accountReferences: ["ACCOUNT_1"]
+	*  appReferences: [123n, 1234n]
+	*  assetReferences: [12345n]
+	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+	*  accessReferences: [{ appId: 1234n }]
+	*  lease: 'lease',
+	*  note: 'note',
+	*  // You wouldn't normally set this field
+	*  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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppCallMethodCall(params) {
+		this.validateReferenceParams(params);
+		const txnArgs = extractComposerTransactionsFromAppMethodCallParams(params);
+		this.push(...txnArgs, {
+			data: {
+				...params,
+				args: processAppMethodCallArgs(params.args)
+			},
+			type: "methodCall"
+		});
+		return this;
+	}
+	/**
+	* Add an online key registration transaction to the transaction group.
+	* @param params The online key registration transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addOnlineKeyRegistration({
+	*   sender: 'SENDERADDRESS',
+	*   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+	*   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+	*   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+	*   voteFirst: 1n,
+	*   voteLast: 1000n,
+	*   voteKeyDilution: 1n,
+	* })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addOnlineKeyRegistration({
+	*   sender: 'SENDERADDRESS',
+	*   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+	*   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+	*   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+	*   voteFirst: 1n,
+	*   voteLast: 1000n,
+	*   voteKeyDilution: 1n,
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+	*   rekeyTo: 'REKEYTOADDRESS',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	* ```
+	*/
+	addOnlineKeyRegistration(params) {
+		this.push({
+			data: params,
+			type: "keyReg"
+		});
+		return this;
+	}
+	/**
+	* Add an offline key registration transaction to the transaction group.
+	* @param params The offline key registration transaction parameters
+	* @returns The composer so you can chain method calls
+	* @example Basic example
+	* ```typescript
+	* composer.addOfflineKeyRegistration({
+	*   sender: 'SENDERADDRESS',
+	* })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* composer.addOfflineKeyRegistration({
+	*   sender: 'SENDERADDRESS',
+	*   lease: 'lease',
+	*   note: 'note',
+	*   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+	*   rekeyTo: 'REKEYTOADDRESS',
+	*   // You wouldn't normally set this field
+	*   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(),
+	* })
+	* ```
+	*/
+	addOfflineKeyRegistration(params) {
+		this.push({
+			data: params,
+			type: "keyReg"
+		});
+		return this;
+	}
+	/**
+	* Get the number of transactions currently added to this composer.
+	* @returns The number of transactions currently added to this composer
+	*/
+	count() {
+		return this.txns.length;
+	}
+	/**
+	* Build the transaction composer.
+	*
+	* This method performs resource population and inner transaction fee coverage if these options are set in the composer.
+	*
+	* Once this method is called, no further transactions will be able to be added.
+	* You can safely call this method multiple times to get the same result.
+	* @returns The built transaction composer, the transactions and any corresponding method calls
+	* @example
+	* ```typescript
+	* const { transactions, methodCalls } = await composer.build()
+	* ```
+	*/
+	async build() {
+		if (!this.transactionsWithSigners) {
+			const suggestedParams = await this.getSuggestedParams();
+			const builtTransactions = await this._buildTransactions(suggestedParams);
+			this.rawBuildTransactions = builtTransactions.transactions.map((txn) => new Transaction({ ...txn }));
+			const groupAnalysis = (this.composerConfig.coverAppCallInnerTransactionFees || this.composerConfig.populateAppCallResources) && builtTransactions.transactions.some((txn) => txn.type === TransactionType.AppCall) ? await this.analyzeGroupRequirements(builtTransactions.transactions, suggestedParams, this.composerConfig) : void 0;
+			this.populateTransactionAndGroupResources(builtTransactions.transactions, groupAnalysis);
+			this.transactionsWithSigners = builtTransactions.transactions.map((txn, index) => {
+				return {
+					txn,
+					signer: builtTransactions.signers.get(index) ?? this.getSigner(txn.sender)
+				};
+			});
+		}
+		const methodCalls = /* @__PURE__ */ new Map();
+		this.txns.forEach((txn, index) => {
+			if (txn.type === "methodCall") methodCalls.set(index, txn.data.method);
+		});
+		return {
+			transactions: this.transactionsWithSigners,
+			methodCalls
+		};
+	}
+	async _buildTransactions(suggestedParams) {
+		const defaultValidityWindow = !this.defaultValidityWindowIsExplicit && genesisIdIsLocalNet(suggestedParams.genesisId ?? "unknown") ? 1000n : this.defaultValidityWindow;
+		const signers = /* @__PURE__ */ new Map();
+		const transactions = new Array();
+		let transactionIndex = 0;
+		for (const ctxn of this.txns) if (ctxn.type === "txn") {
+			transactions.push(ctxn.data.txn);
+			if (ctxn.data.signer) signers.set(transactionIndex, ctxn.data.signer);
+			transactionIndex++;
+		} else if (ctxn.type === "asyncTxn") {
+			transactions.push(await ctxn.data.txn);
+			if (ctxn.data.signer) signers.set(transactionIndex, ctxn.data.signer);
+			transactionIndex++;
+		} else {
+			let transaction;
+			switch (ctxn.type) {
+				case "pay":
+					transaction = buildPayment(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetCreate":
+					transaction = buildAssetCreate(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetConfig":
+					transaction = buildAssetConfig(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetFreeze":
+					transaction = buildAssetFreeze(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetDestroy":
+					transaction = buildAssetDestroy(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetTransfer":
+					transaction = buildAssetTransfer(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetOptIn":
+					transaction = buildAssetOptIn(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetOptOut":
+					transaction = buildAssetOptOut(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "appCall":
+					if (ctxn.data.appId === void 0 || ctxn.data.appId === 0) transaction = await buildAppCreate(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
+					else if ("approvalProgram" in ctxn.data && "clearStateProgram" in ctxn.data) transaction = await buildAppUpdate(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
+					else transaction = buildAppCall(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "keyReg":
+					transaction = buildKeyReg(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "methodCall":
+					if (ctxn.data.appId === void 0 || ctxn.data.appId === 0) transaction = await buildAppCreateMethodCall(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
+					else if ("approvalProgram" in ctxn.data && "clearStateProgram" in ctxn.data) transaction = await buildAppUpdateMethodCall(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
+					else transaction = await buildAppCallMethodCall(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				default: throw new Error(`Unsupported transaction type: ${ctxn.type}`);
+			}
+			if (transaction.fee === void 0) transaction = assignFee(transaction, {
+				feePerByte: suggestedParams.fee,
+				minFee: suggestedParams.minFee,
+				extraFee: ctxn.data.extraFee?.microAlgos,
+				maxFee: ctxn.data.maxFee?.microAlgos
+			});
+			transactions.push(transaction);
+			if (ctxn.data.signer) {
+				const signer = "signer" in ctxn.data.signer ? ctxn.data.signer.signer : ctxn.data.signer;
+				signers.set(transactionIndex, signer);
+			}
+			transactionIndex++;
+		}
+		if (transactions.length > MAX_TRANSACTION_GROUP_SIZE) throw new Error(`Transaction group size ${transactions.length} exceeds the maximum limit of ${MAX_TRANSACTION_GROUP_SIZE}`);
+		const methodCalls = /* @__PURE__ */ new Map();
+		this.txns.forEach((txn, index) => {
+			if (txn.type === "methodCall") methodCalls.set(index, txn.data.method);
+		});
+		return {
+			transactions,
+			methodCalls,
+			signers
+		};
+	}
+	/**
+	* Builds all transactions in the composer and returns them along with method calls and signers.
+	*
+	* Note: This method only builds the transactions as-is without resource population or automatic grouping.
+	* Use this when you need the raw transactions.
+	* @returns An object containing the array of built transactions, method calls, and signers
+	* @example
+	* ```typescript
+	* const { transactions, methodCalls, signers } = await composer.buildTransactions()
+	* ```
+	*/
+	async buildTransactions() {
+		const suggestedParams = await this.getSuggestedParams();
+		const buildResult = await this._buildTransactions(suggestedParams);
+		return {
+			...buildResult,
+			transactions: buildResult.transactions
+		};
+	}
+	populateTransactionAndGroupResources(transactions, groupAnalysis) {
+		if (groupAnalysis) {
+			let surplusGroupFees = 0n;
+			const transactionAnalysis = [];
+			groupAnalysis.transactions.forEach((txnAnalysis, groupIndex) => {
+				if (txnAnalysis.requiredFeeDelta && FeeDelta.isSurplus(txnAnalysis.requiredFeeDelta)) surplusGroupFees += FeeDelta.amount(txnAnalysis.requiredFeeDelta);
+				const ctxn = this.txns[groupIndex];
+				const txn = transactions[groupIndex];
+				const logicalMaxFee = getLogicalMaxFee(ctxn);
+				const isImmutableFee = logicalMaxFee !== void 0 && logicalMaxFee === (txn.fee || 0n);
+				let priority = FeePriority.Covered;
+				if (txnAnalysis.requiredFeeDelta && FeeDelta.isDeficit(txnAnalysis.requiredFeeDelta)) {
+					const deficitAmount = FeeDelta.amount(txnAnalysis.requiredFeeDelta);
+					if (isImmutableFee || txn.type !== TransactionType.AppCall) priority = FeePriority.ImmutableDeficit(deficitAmount);
+					else priority = FeePriority.ModifiableDeficit(deficitAmount);
+				}
+				transactionAnalysis.push({
+					groupIndex,
+					requiredFeeDelta: txnAnalysis.requiredFeeDelta,
+					priority,
+					unnamedResourcesAccessed: txnAnalysis.unnamedResourcesAccessed
+				});
+			});
+			transactionAnalysis.sort((a, b) => b.priority.compare(a.priority));
+			const indexesWithAccessReferences = [];
+			for (const { groupIndex, requiredFeeDelta, unnamedResourcesAccessed } of transactionAnalysis) {
+				if (requiredFeeDelta && FeeDelta.isDeficit(requiredFeeDelta)) {
+					const deficitAmount = FeeDelta.amount(requiredFeeDelta);
+					let additionalFeeDelta;
+					if (surplusGroupFees === 0n) additionalFeeDelta = requiredFeeDelta;
+					else if (surplusGroupFees >= deficitAmount) surplusGroupFees -= deficitAmount;
+					else {
+						additionalFeeDelta = FeeDelta.fromBigInt(deficitAmount - surplusGroupFees);
+						surplusGroupFees = 0n;
+					}
+					if (additionalFeeDelta && FeeDelta.isDeficit(additionalFeeDelta)) {
+						const additionalDeficitAmount = FeeDelta.amount(additionalFeeDelta);
+						if (transactions[groupIndex].type === TransactionType.AppCall) {
+							const transactionFee = (transactions[groupIndex].fee || 0n) + additionalDeficitAmount;
+							const logicalMaxFee = getLogicalMaxFee(this.txns[groupIndex]);
+							if (!logicalMaxFee || transactionFee > logicalMaxFee) throw new Error(`Calculated transaction fee ${transactionFee} µALGO is greater than max of ${logicalMaxFee ?? 0n} for transaction ${groupIndex}`);
+							transactions[groupIndex].fee = transactionFee;
+						} else throw new Error(`An additional fee of ${additionalDeficitAmount} µALGO is required for non app call transaction ${groupIndex}`);
+					}
+				}
+				if (unnamedResourcesAccessed && transactions[groupIndex].type === TransactionType.AppCall) if (!(transactions[groupIndex].appCall?.accessReferences && transactions[groupIndex].appCall?.accessReferences?.length)) populateTransactionResources(transactions[groupIndex], unnamedResourcesAccessed, groupIndex);
+				else indexesWithAccessReferences.push(groupIndex);
+			}
+			if (indexesWithAccessReferences.length > 0) Config.logger.warn(`Resource population will be skipped for transaction indexes ${indexesWithAccessReferences.join(", ")} as they use access references.`);
+			if (groupAnalysis.unnamedResourcesAccessed) populateGroupResources(transactions, groupAnalysis.unnamedResourcesAccessed);
+		}
+		if (transactions.length > 1) {
+			const groupedTransactions = groupTransactions(transactions);
+			transactions.forEach((t) => t.group = groupedTransactions[0].group);
+			return transactions;
+		} else return transactions;
+	}
+	async analyzeGroupRequirements(transactions, suggestedParams, analysisParams) {
+		const appCallIndexesWithoutMaxFees = [];
+		let transactionsToSimulate = transactions.map((txn, groupIndex) => {
+			const ctxn = this.txns[groupIndex];
+			const params = { ...txn };
+			delete params.group;
+			if (analysisParams.coverAppCallInnerTransactionFees && txn.type === TransactionType.AppCall) {
+				const logicalMaxFee = getLogicalMaxFee(ctxn);
+				if (logicalMaxFee !== void 0) params.fee = logicalMaxFee;
+				else appCallIndexesWithoutMaxFees.push(groupIndex);
+			}
+			return new Transaction(params);
+		});
+		if (transactionsToSimulate.length > 1) transactionsToSimulate = groupTransactions(transactionsToSimulate);
+		if (analysisParams.coverAppCallInnerTransactionFees && appCallIndexesWithoutMaxFees.length > 0) throw new Error(`Please provide a maxFee for each app call transaction when coverAppCallInnerTransactionFees is enabled. Required for transaction ${appCallIndexesWithoutMaxFees.join(", ")}`);
+		const simulateRequest = {
+			txnGroups: [{ txns: transactionsToSimulate.map((txn) => ({
+				txn,
+				sig: EMPTY_SIGNATURE
+			})) }],
+			allowUnnamedResources: true,
+			allowEmptySignatures: true,
+			fixSigners: true,
+			allowMoreLogging: true,
+			execTraceConfig: {
+				enable: true,
+				scratchChange: true,
+				stackChange: true,
+				stateChange: true
+			}
+		};
+		const groupResponse = (await this.algod.simulateTransactions(simulateRequest)).txnGroups[0];
+		if (groupResponse.failureMessage) {
+			if (analysisParams.coverAppCallInnerTransactionFees && groupResponse.failureMessage.includes("fee too small")) throw new Error("Fees were too small to resolve execution info via simulate. You may need to increase an app call transaction maxFee.");
+			throw new Error(`Error resolving execution info via simulate in transaction ${groupResponse.failedAt?.join(", ")}: ${groupResponse.failureMessage}`);
+		}
+		const txnAnalysisResults = groupResponse.txnResults.map((simulateTxnResult, groupIndex) => {
+			const btxn = transactions[groupIndex];
+			let requiredFeeDelta;
+			if (analysisParams.coverAppCallInnerTransactionFees) {
+				const minTxnFee = calculateFee(btxn, {
+					feePerByte: suggestedParams.fee,
+					minFee: suggestedParams.minFee
+				});
+				const txnFeeDelta = FeeDelta.fromBigInt(minTxnFee - (btxn.fee ?? 0n));
+				if (btxn.type === TransactionType.AppCall) {
+					const innerTxnsFeeDelta = calculateInnerFeeDelta(simulateTxnResult.txnResult.innerTxns, suggestedParams.minFee);
+					requiredFeeDelta = FeeDelta.fromBigInt((innerTxnsFeeDelta ? FeeDelta.toBigInt(innerTxnsFeeDelta) : 0n) + (txnFeeDelta ? FeeDelta.toBigInt(txnFeeDelta) : 0n));
+				} else requiredFeeDelta = txnFeeDelta;
+			}
+			return {
+				requiredFeeDelta,
+				unnamedResourcesAccessed: analysisParams.populateAppCallResources ? simulateTxnResult.unnamedResourcesAccessed : void 0
+			};
+		});
+		const sortedResources = groupResponse.unnamedResourcesAccessed;
+		const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+		if (sortedResources) {
+			sortedResources.accounts?.sort((a, b) => compare(a.toString(), b.toString()));
+			sortedResources.assets?.sort(compare);
+			sortedResources.apps?.sort(compare);
+			sortedResources.boxes?.sort((a, b) => {
+				return compare(`${a.appId}-${a.name}`, `${b.appId}-${b.name}`);
+			});
+			sortedResources.appLocals?.sort((a, b) => {
+				return compare(`${a.appId}-${a.address}`, `${b.appId}-${b.address}`);
+			});
+			sortedResources.assetHoldings?.sort((a, b) => {
+				return compare(`${a.assetId}-${a.address}`, `${b.assetId}-${b.address}`);
+			});
+		}
+		return {
+			transactions: txnAnalysisResults,
+			unnamedResourcesAccessed: analysisParams.populateAppCallResources ? sortedResources : void 0
+		};
+	}
+	/**
+	* Rebuild the group, discarding any previously built transactions.
+	* This will potentially cause new signers and suggested params to be used if the callbacks return a new value compared to the first build.
+	* @returns The newly built transaction composer and the transactions
+	* @example
+	* ```typescript
+	* const { atc, transactions, methodCalls } = await composer.rebuild()
+	* ```
+	*/
+	async rebuild() {
+		this.reset();
+		return await this.build();
+	}
+	reset() {
+		this.signedTransactions = void 0;
+		this.transactionsWithSigners = void 0;
+	}
+	/**
+	* Compose the transaction group and send it to the network.
+	* @param params The parameters to control execution with
+	* @returns The execution result
+	* @example
+	* ```typescript
+	* const result = await composer.send()
+	* ```
+	*/
+	async send(params) {
+		if (this.composerConfig.coverAppCallInnerTransactionFees !== (params?.coverAppCallInnerTransactionFees ?? false) || this.composerConfig.populateAppCallResources !== (params?.populateAppCallResources ?? true)) {
+			this.composerConfig = {
+				coverAppCallInnerTransactionFees: params?.coverAppCallInnerTransactionFees ?? false,
+				populateAppCallResources: params?.populateAppCallResources ?? true
+			};
+			this.reset();
+		}
+		try {
+			await this.gatherSignatures();
+			if (!this.transactionsWithSigners || this.transactionsWithSigners.length === 0 || !this.signedTransactions || this.signedTransactions.length === 0) throw new Error("No transactions available");
+			const transactionsToSend = this.transactionsWithSigners.map((stxn) => stxn.txn);
+			const transactionIds = transactionsToSend.map((txn) => txn.txId());
+			if (transactionsToSend.length > 1) {
+				const groupId = transactionsToSend[0].group ? Buffer.from(transactionsToSend[0].group).toString("base64") : "";
+				Config.getLogger(params?.suppressLog).verbose(`Sending group of ${transactionsToSend.length} transactions (${groupId})`, { transactionsToSend });
+				Config.getLogger(params?.suppressLog).debug(`Transaction IDs (${groupId})`, transactionIds);
+			}
+			if (Config.debug && Config.traceAll) await this.simulate({
+				allowEmptySignatures: true,
+				fixSigners: true,
+				allowMoreLogging: true,
+				execTraceConfig: {
+					enable: true,
+					scratchChange: true,
+					stackChange: true,
+					stateChange: true
+				},
+				resultOnFailure: true
+			});
+			const group = this.signedTransactions[0].txn.group;
+			let waitRounds = params?.maxRoundsToWaitForConfirmation;
+			if (waitRounds === void 0) {
+				const firstRound = (await this.getSuggestedParams()).firstValid;
+				const lastRound = this.signedTransactions.reduce((max, txn) => txn.txn.lastValid > max ? txn.txn.lastValid : max, 0n);
+				waitRounds = Number(lastRound - firstRound) + 1;
+			}
+			const encodedTxns = encodeSignedTransactions(this.signedTransactions);
+			await this.algod.sendRawTransaction(encodedTxns);
+			if (transactionsToSend.length > 1 && group) Config.getLogger(params?.suppressLog).verbose(`Group transaction (${Buffer.from(group).toString("base64")}) sent with ${transactionsToSend.length} transactions`);
+			else Config.getLogger(params?.suppressLog).verbose(`Sent transaction ID ${transactionsToSend[0].txId()} ${transactionsToSend[0].type} from ${transactionsToSend[0].sender}`);
+			let confirmations = new Array();
+			if (params?.maxRoundsToWaitForConfirmation !== 0) confirmations = await Promise.all(transactionIds.map(async (id) => await waitForConfirmation(id, waitRounds, this.algod)));
+			const abiReturns = this.parseAbiReturnValues(confirmations);
+			return {
+				groupId: group ? Buffer.from(group).toString("base64") : void 0,
+				transactions: transactionsToSend,
+				txIds: transactionIds,
+				returns: abiReturns,
+				confirmations
+			};
+		} catch (originalError) {
+			const errorMessage = originalError.body?.message ?? originalError.message ?? "Received error executing Transaction Composer";
+			const err = new Error(errorMessage);
+			err.cause = originalError;
+			if (typeof originalError === "object") err.name = originalError.name;
+			let sentTransactions;
+			if (this.transactionsWithSigners) sentTransactions = this.transactionsWithSigners.map((t) => t.txn);
+			else if (this.rawBuildTransactions) sentTransactions = this.rawBuildTransactions.length > 1 ? groupTransactions(this.rawBuildTransactions) : this.rawBuildTransactions;
+			if (Config.debug && typeof originalError === "object" && sentTransactions) {
+				err.traces = [];
+				Config.getLogger(params?.suppressLog).error("Received error executing Transaction Composer and debug flag enabled; attempting simulation to get more information", err);
+				const transactionsWithEmptySigners = sentTransactions.map((txn) => ({
+					txn,
+					signer: makeEmptyTransactionSigner()
+				}));
+				const signedTransactions = await this.signTransactions(transactionsWithEmptySigners);
+				const simulateResponse = await this.algod.simulateTransactions({
+					txnGroups: [{ txns: signedTransactions }],
+					allowEmptySignatures: true,
+					fixSigners: true,
+					allowMoreLogging: true,
+					execTraceConfig: {
+						enable: true,
+						scratchChange: true,
+						stackChange: true,
+						stateChange: true
+					}
+				});
+				if (Config.debug && !Config.traceAll) await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateResponse });
+				if (simulateResponse && simulateResponse.txnGroups[0].failedAt) for (const txn of simulateResponse.txnGroups[0].txnResults) err.traces.push({
+					trace: txn.execTrace,
+					appBudget: txn.appBudgetConsumed,
+					logicSigBudget: txn.logicSigBudgetConsumed,
+					logs: txn.txnResult.logs,
+					message: simulateResponse.txnGroups[0].failureMessage
+				});
+			} else Config.getLogger(params?.suppressLog).error("Received error executing Transaction Composer, for more information enable the debug flag", err);
+			err.sentTransactions = sentTransactions ?? [];
+			throw await this.transformError(err);
+		}
+	}
+	async simulate(options) {
+		const { skipSignatures = false, resultOnFailure = false, ...rawOptions } = options ?? {};
+		if (skipSignatures) {
+			rawOptions.allowEmptySignatures = true;
+			rawOptions.fixSigners = true;
+		}
+		let transactionsWithSigner;
+		if (!this.transactionsWithSigners) {
+			const builtTransactions = await this.buildTransactions();
+			transactionsWithSigner = (builtTransactions.transactions.length > 0 ? groupTransactions(builtTransactions.transactions) : builtTransactions.transactions).map((txn, index) => ({
+				txn,
+				signer: skipSignatures ? makeEmptyTransactionSigner() : builtTransactions.signers.get(index) ?? makeEmptyTransactionSigner()
+			}));
+		} else transactionsWithSigner = this.transactionsWithSigners.map((e) => ({
+			txn: e.txn,
+			signer: skipSignatures ? makeEmptyTransactionSigner() : e.signer
+		}));
+		const transactions = transactionsWithSigner.map((e) => e.txn);
+		const simulateRequest = {
+			txnGroups: [{ txns: await this.signTransactions(transactionsWithSigner) }],
+			...rawOptions,
+			...Config.debug ? {
+				allowEmptySignatures: true,
+				fixSigners: true,
+				allowMoreLogging: true,
+				execTraceConfig: {
+					enable: true,
+					scratchChange: true,
+					stackChange: true,
+					stateChange: true
+				}
+			} : void 0
+		};
+		const simulateResponse = await this.algod.simulateTransactions(simulateRequest);
+		const simulateResult = simulateResponse.txnGroups[0];
+		if (simulateResult?.failureMessage && !resultOnFailure) {
+			const errorMessage = `Transaction failed at transaction(s) ${simulateResult.failedAt?.join(", ") || "unknown"} in the group. ${simulateResult.failureMessage}`;
+			const error = new Error(errorMessage);
+			if (Config.debug) await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateTransaction: simulateResponse });
+			throw await this.transformError(error);
+		}
+		if (Config.debug && Config.traceAll) await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateTransaction: simulateResponse });
+		const abiReturns = this.parseAbiReturnValues(simulateResult.txnResults.map((t) => t.txnResult));
+		return {
+			confirmations: simulateResult.txnResults.map((t) => t.txnResult),
+			transactions,
+			txIds: transactions.map((t) => t.txId()),
+			groupId: Buffer.from(transactions[0].group ?? new Uint8Array()).toString("base64"),
+			simulateResponse,
+			returns: abiReturns
+		};
+	}
+	/**
+	* Create an encoded transaction note that follows the ARC-2 spec.
+	*
+	* https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md
+	* @param note The ARC-2 transaction note data
+	* @returns The binary encoded transaction note
+	*/
+	static arc2Note(note) {
+		const arc2Payload = `${note.dAppName}:${note.format}${typeof note.data === "string" ? note.data : asJson(note.data)}`;
+		return new TextEncoder().encode(arc2Payload);
+	}
+	async gatherSignatures() {
+		if (this.signedTransactions) return this.signedTransactions;
+		await this.build();
+		if (!this.transactionsWithSigners || this.transactionsWithSigners.length === 0) throw new Error("No transactions available to sign");
+		this.signedTransactions = await this.signTransactions(this.transactionsWithSigners);
+		return this.signedTransactions;
+	}
+	async signTransactions(transactionsWithSigners) {
+		if (transactionsWithSigners.length === 0) throw new Error("No transactions available to sign");
+		const transactions = transactionsWithSigners.map((txnWithSigner) => txnWithSigner.txn);
+		const signerGroups = /* @__PURE__ */ new Map();
+		transactionsWithSigners.forEach(({ signer }, index) => {
+			const indexes = signerGroups.get(signer) ?? [];
+			indexes.push(index);
+			signerGroups.set(signer, indexes);
+		});
+		const signerEntries = Array.from(signerGroups);
+		const signedGroups = await Promise.all(signerEntries.map(([signer, indexes]) => signer(transactions, indexes)));
+		const signedTransactions = new Array(transactionsWithSigners.length);
+		signerEntries.forEach(([, indexes], signerIndex) => {
+			const stxs = signedGroups[signerIndex];
+			indexes.forEach((txIndex, stxIndex) => {
+				signedTransactions[txIndex] = decodeSignedTransaction(stxs[stxIndex]);
+			});
+		});
+		const unsignedIndexes = signedTransactions.map((stxn, index) => stxn === void 0 ? index : null).filter((index) => index !== null);
+		if (unsignedIndexes.length > 0) throw new Error(`Transactions at indexes [${unsignedIndexes.join(", ")}] were not signed`);
+		return signedTransactions;
+	}
+	parseAbiReturnValues(confirmations) {
+		const abiReturns = new Array();
+		for (let i = 0; i < confirmations.length; i++) {
+			const confirmation = confirmations[i];
+			const txn = this.txns[i];
+			if (txn?.type !== "methodCall") continue;
+			const abiReturn = AppManager.getABIReturn(confirmation, txn.data.method);
+			if (abiReturn !== void 0) abiReturns.push(abiReturn);
+		}
+		return abiReturns;
+	}
+	setMaxFees(maxFees) {
+		maxFees.forEach((_, index) => {
+			if (index > this.txns.length - 1) throw new Error(`Index ${index} is out of range. The composer only contains ${this.txns.length} transactions`);
+		});
+		maxFees.forEach((maxFee, index) => {
+			this.txns[index].data.maxFee = new AlgoAmount({ microAlgos: maxFee.microAlgos });
+		});
+	}
+};
+/** Get the logical maximum fee based on staticFee and maxFee */
+function getLogicalMaxFee(ctxn) {
+	if (ctxn.type === "txn" || ctxn.type === "asyncTxn") return;
+	const maxFee = ctxn.data.maxFee;
+	const staticFee = ctxn.data.staticFee;
+	if (maxFee !== void 0 && (staticFee === void 0 || maxFee.microAlgos > staticFee.microAlgos)) return maxFee.microAlgos;
+	return staticFee?.microAlgos;
 }
 
-export { MAX_TRANSACTION_GROUP_SIZE, TransactionComposer };
-//# sourceMappingURL=composer.mjs.map
+//#endregion
+export { TransactionComposer };
+//# sourceMappingURL=composer.mjs.map