@algorandfoundation/algokit-utils 6.2.1 → 7.0.0-alpha.1

package/types/composer.js

@@ -1,20 +1,24 @@
 'use strict';
 
 var algosdk = require('algosdk');
-var transaction = require('../transaction/transaction.js');
-var types_clientManager = require('./client-manager.js');
+var config = require('../src/config.js');
+var transaction = require('../src/transaction/transaction.js');
+var types_app = require('./app.js');
+var types_appManager = require('./app-manager.js');
+var types_lifecycleEvents = require('./lifecycle-events.js');
+var types_networkClient = require('./network-client.js');
 
+var AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
 var isTransactionWithSigner = algosdk.isTransactionWithSigner;
-var encodeAddress = algosdk.encodeAddress;
-/** AlgoKit Composer helps you compose and execute transactions as a transaction group.
- *
- * Note: this class is a new Beta feature and may be subject to change.
- *
- * @beta
- */
-class AlgokitComposer {
+var modelsv2 = algosdk.modelsv2;
+const address = (address) => {
+    return typeof address === 'string' ? algosdk.Address.fromString(address) : address;
+};
+const MAX_TRANSACTION_GROUP_SIZE = 16;
+/** TransactionComposer helps you compose and execute transactions as a transaction group. */
+class TransactionComposer {
     /**
-     * Create an `AlgoKitComposer`.
+     * Create a `TransactionComposer`.
      * @param params The configuration for this composer
      */
     constructor(params) {
@@ -25,7 +29,7 @@ class AlgokitComposer {
         /** Transactions that have not yet been composed */
         this.txns = [];
         /** The default transaction validity window */
-        this.defaultValidityWindow = 10;
+        this.defaultValidityWindow = 10n;
         /** Whether the validity window was explicitly set on construction */
         this.defaultValidityWindowIsExplicit = false;
         this.algod = params.algod;
@@ -34,6 +38,21 @@ class AlgokitComposer {
         this.getSigner = params.getSigner;
         this.defaultValidityWindow = params.defaultValidityWindow ?? this.defaultValidityWindow;
         this.defaultValidityWindowIsExplicit = params.defaultValidityWindow !== undefined;
+        this.appManager = params.appManager ?? new types_appManager.AppManager(params.algod);
+    }
+    /**
+     * 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
+     */
+    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.
@@ -98,9 +117,53 @@ class AlgokitComposer {
         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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
@@ -110,13 +173,46 @@ class AlgokitComposer {
         return this;
     }
     /**
-     * Add an ABI method application call transaction to the transaction group.
+     * 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
+     */
+    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
+     */
+    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
+     */
+    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
      */
-    addMethodCall(params) {
+    addAppCallMethodCall(params) {
         this.txns.push({ ...params, type: 'methodCall' });
         return this;
     }
@@ -138,150 +234,206 @@ class AlgokitComposer {
         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) => {
+        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 stash the ABIMethod for later
+            if (atc['methodCalls'].get(idx)) {
+                this.txnMethodMap.set(ts.txn.txID(), atc['methodCalls'].get(idx));
+            }
             return ts;
         });
-        const method = atc['methodCalls'].get(group.length - 1);
-        if (method)
-            this.txnMethodMap.set(txnWithSigners.at(-1).txn.txID(), method);
         return txnWithSigners;
     }
-    commonTxnBuildStep(params, txn, suggestedParams) {
+    commonTxnBuildStep(buildTxn, params, txnParams) {
+        // We are going to mutate suggested params, let's create a clone first
+        txnParams.suggestedParams = { ...txnParams.suggestedParams };
         if (params.lease)
-            txn.addLease(transaction.encodeLease(params.lease));
+            txnParams.lease = transaction.encodeLease(params.lease);
         if (params.rekeyTo)
-            txn.addRekey(params.rekeyTo);
+            txnParams.rekeyTo = address(params.rekeyTo);
+        const encoder = new TextEncoder();
         if (params.note)
-            txn.note = transaction.encodeTransactionNote(params.note);
+            txnParams.note = (typeof params.note === 'string' ? encoder.encode(params.note) : params.note);
         if (params.firstValidRound) {
-            txn.firstRound = Number(params.firstValidRound);
+            txnParams.suggestedParams.firstValid = params.firstValidRound;
         }
         if (params.lastValidRound) {
-            txn.lastRound = Number(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 ??
-                (!this.defaultValidityWindowIsExplicit && types_clientManager.ClientManager.genesisIdIsLocalNet(suggestedParams.genesisID)
-                    ? 1000
-                    : this.defaultValidityWindow);
-            txn.lastRound = txn.firstRound + window;
+            const window = params.validityWindow
+                ? BigInt(params.validityWindow)
+                : !this.defaultValidityWindowIsExplicit && types_networkClient.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) {
-            txn.fee = params.staticFee.microAlgos;
+            txnParams.suggestedParams.fee = params.staticFee.microAlgo;
+            txnParams.suggestedParams.flatFee = true;
         }
-        else {
-            txn.fee = txn.estimateSize() * suggestedParams.fee || algosdk.ALGORAND_MIN_TX_FEE;
-            if (params.extraFee)
-                txn.fee += params.extraFee.microAlgos;
-        }
-        txn.flatFee = true;
-        if (params.maxFee !== undefined && txn.fee > params.maxFee.microAlgos) {
-            throw Error(`Transaction fee ${txn.fee} is greater than maxFee ${params.maxFee}`);
+        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}`);
         }
         return txn;
     }
-    async buildMethodCall(params, suggestedParams) {
+    /**
+     * 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 ['boolean', 'number', 'bigint', 'string', 'Uint8Array'].includes(typeof x);
+            return typeof x === 'bigint' || typeof x === 'boolean' || typeof x === 'number' || typeof x === 'string' || x instanceof Uint8Array;
         };
-        for (const arg of params.args ?? []) {
+        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;
             }
+            // Underlying ATC only supports addresses as strings
+            if (arg instanceof algosdk.Address) {
+                methodArgs.push(arg.toString());
+                continue;
+            }
             if (isTransactionWithSigner(arg)) {
                 methodArgs.push(arg);
                 continue;
             }
             if ('method' in arg) {
-                const tempTxnWithSigners = await this.buildMethodCall(arg, suggestedParams);
-                methodArgs.push(...tempTxnWithSigners);
+                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: params.signer
-                    ? 'signer' in params.signer
-                        ? params.signer.signer
-                        : params.signer
-                    : this.getSigner(encodeAddress(txn.from.publicKey)),
+                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 appID = Number(params.appId || 0);
-        methodAtc.addMethodCall({
-            appID,
+        transactionsForGroup.reverse().forEach((txn) => methodAtc.addTransaction(txn));
+        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,
+            onComplete: params.onComplete ?? algosdk.OnApplicationComplete.NoOpOC,
             appAccounts: params.accountReferences,
             appForeignApps: params.appReferences?.map((x) => Number(x)),
             appForeignAssets: params.assetReferences?.map((x) => Number(x)),
-            approvalProgram: params.approvalProgram,
-            clearProgram: params.clearProgram,
-            extraPages: params.extraPages,
-            numLocalInts: params.schema?.localUints || (appID === 0 ? 0 : undefined),
-            numLocalByteSlices: params.schema?.localByteSlices || (appID === 0 ? 0 : undefined),
-            numGlobalInts: params.schema?.globalUints || (appID === 0 ? 0 : undefined),
-            numGlobalByteSlices: params.schema?.globalByteSlices || (appID === 0 ? 0 : undefined),
+            boxes: params.boxReferences?.map(types_appManager.AppManager.getBoxReference),
+            approvalProgram,
+            clearProgram: clearStateProgram,
+            extraPages: appId === 0
+                ? 'extraProgramPages' in params && params.extraProgramPages !== undefined
+                    ? params.extraProgramPages
+                    : approvalProgram
+                        ? Math.floor((approvalProgram.length + (clearStateProgram?.length ?? 0)) / types_app.APP_PAGE_MAX_SIZE)
+                        : 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: params.signer ? ('signer' in params.signer ? params.signer.signer : params.signer) : this.getSigner(params.sender),
-            methodArgs: methodArgs,
+            signer: includeSigner
+                ? params.signer
+                    ? 'signer' in params.signer
+                        ? params.signer.signer
+                        : params.signer
+                    : this.getSigner(params.sender)
+                : TransactionComposer.NULL_SIGNER,
+            methodArgs: methodArgs.reverse(),
             // note, lease, and rekeyTo are set in the common build step
             note: undefined,
             lease: undefined,
             rekeyTo: undefined,
-        });
-        // Run the actual method call txn through the common build step to set fees and validity rounds
-        const group = methodAtc.buildGroup();
-        const methodIdx = group.length - 1;
-        group[methodIdx].txn = this.commonTxnBuildStep(params, group[methodIdx].txn, suggestedParams);
+        };
+        // Build the transaction
+        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);
     }
     buildPayment(params, suggestedParams) {
-        const txn = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
-            from: params.sender,
-            to: params.receiver,
-            amount: params.amount.microAlgos,
+        return this.commonTxnBuildStep(algosdk.makePaymentTxnWithSuggestedParamsFromObject, params, {
+            sender: params.sender,
+            receiver: params.receiver,
+            amount: params.amount.microAlgo,
             closeRemainderTo: params.closeRemainderTo,
             suggestedParams,
         });
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
     }
     buildAssetCreate(params, suggestedParams) {
-        const txn = algosdk.makeAssetCreateTxnWithSuggestedParamsFromObject({
-            from: params.sender,
+        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: params.metadataHash,
+            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,
         });
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
     }
     buildAssetConfig(params, suggestedParams) {
-        const txn = algosdk.makeAssetConfigTxnWithSuggestedParamsFromObject({
-            from: params.sender,
-            assetIndex: Number(params.assetId),
+        return this.commonTxnBuildStep(algosdk.makeAssetConfigTxnWithSuggestedParamsFromObject, params, {
+            sender: params.sender,
+            assetIndex: params.assetId,
             suggestedParams,
             manager: params.manager,
             reserve: params.reserve,
@@ -289,76 +441,120 @@ class AlgokitComposer {
             clawback: params.clawback,
             strictEmptyAddressChecking: false,
         });
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
     }
     buildAssetDestroy(params, suggestedParams) {
-        const txn = algosdk.makeAssetDestroyTxnWithSuggestedParamsFromObject({
-            from: params.sender,
-            assetIndex: Number(params.assetId),
+        return this.commonTxnBuildStep(algosdk.makeAssetDestroyTxnWithSuggestedParamsFromObject, params, {
+            sender: params.sender,
+            assetIndex: params.assetId,
             suggestedParams,
         });
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
     }
     buildAssetFreeze(params, suggestedParams) {
-        const txn = algosdk.makeAssetFreezeTxnWithSuggestedParamsFromObject({
-            from: params.sender,
-            assetIndex: Number(params.assetId),
+        return this.commonTxnBuildStep(algosdk.makeAssetFreezeTxnWithSuggestedParamsFromObject, params, {
+            sender: params.sender,
+            assetIndex: params.assetId,
             freezeTarget: params.account,
-            freezeState: params.frozen,
+            frozen: params.frozen,
             suggestedParams,
         });
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
     }
     buildAssetTransfer(params, suggestedParams) {
-        const txn = algosdk.makeAssetTransferTxnWithSuggestedParamsFromObject({
-            from: params.sender,
-            to: params.receiver,
-            assetIndex: Number(params.assetId),
+        return this.commonTxnBuildStep(algosdk.makeAssetTransferTxnWithSuggestedParamsFromObject, params, {
+            sender: params.sender,
+            receiver: params.receiver,
+            assetIndex: params.assetId,
             amount: params.amount,
             suggestedParams,
             closeRemainderTo: params.closeAssetTo,
-            revocationTarget: params.clawbackTarget,
+            assetSender: params.clawbackTarget,
         });
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
     }
-    buildAppCall(params, suggestedParams) {
+    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 = {
-            from: params.sender,
+            sender: params.sender,
             suggestedParams,
-            onComplete: params.onComplete,
-            approvalProgram: params.approvalProgram,
-            clearProgram: params.clearProgram,
             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)),
-            extraPages: params.extraPages,
-            numLocalInts: params.schema?.localUints || 0,
-            numLocalByteSlices: params.schema?.localByteSlices || 0,
-            numGlobalInts: params.schema?.globalUints || 0,
-            numGlobalByteSlices: params.schema?.globalByteSlices || 0,
+            boxes: params.boxReferences?.map(types_appManager.AppManager.getBoxReference),
+            approvalProgram,
+            clearProgram: clearStateProgram,
         };
-        let txn;
-        const onComplete = params.onComplete || algosdk.OnApplicationComplete.NoOpOC;
-        if (!params.appId) {
-            if (params.approvalProgram === undefined || params.clearProgram === undefined) {
-                throw new Error('approvalProgram and clearProgram are required for application creation');
+        if (appId === 0n) {
+            if (sdkParams.approvalProgram === undefined || sdkParams.clearProgram === undefined) {
+                throw new Error('approvalProgram and clearStateProgram are required for application creation');
             }
-            txn = algosdk.makeApplicationCreateTxnFromObject({
+            return this.commonTxnBuildStep(algosdk.makeApplicationCreateTxnFromObject, params, {
                 ...sdkParams,
-                onComplete,
-                approvalProgram: params.approvalProgram,
-                clearProgram: params.clearProgram,
+                extraPages: 'extraProgramPages' in params
+                    ? (params.extraProgramPages ?? Math.floor((approvalProgram.length + clearStateProgram.length) / types_app.APP_PAGE_MAX_SIZE))
+                    : 0,
+                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,
             });
         }
-        txn = algosdk.makeApplicationCallTxnFromObject({ ...sdkParams, onComplete, appIndex: Number(params.appId || 0) });
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
+        else {
+            return this.commonTxnBuildStep(algosdk.makeApplicationCallTxnFromObject, params, { ...sdkParams, appIndex: appId });
+        }
     }
     buildKeyReg(params, suggestedParams) {
-        const txn = algosdk.makeKeyRegistrationTxnWithSuggestedParams(params.sender, undefined, params.voteKey, params.selectionKey, Number(params.voteFirst), Number(params.voteLast), Number(params.voteKeyDilution), suggestedParams, undefined, false, params.stateProofKey);
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
+        return this.commonTxnBuildStep(algosdk.makeKeyRegistrationTxnWithSuggestedParamsFromObject, params, {
+            sender: params.sender,
+            voteKey: params.voteKey,
+            selectionKey: params.selectionKey,
+            voteFirst: params.voteFirst,
+            voteLast: params.voteLast,
+            voteKeyDilution: params.voteKeyDilution,
+            stateProofKey: params.stateProofKey,
+            nonParticipation: false,
+            suggestedParams,
+        });
     }
+    /** 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];
         }
@@ -366,75 +562,83 @@ class AlgokitComposer {
             return this.buildAtc(txn.atc);
         }
         if (txn.type === 'methodCall') {
-            return await this.buildMethodCall(txn, suggestedParams);
+            return await this.buildMethodCall(txn, suggestedParams, true);
         }
         const signer = txn.signer ? ('signer' in txn.signer ? txn.signer.signer : txn.signer) : this.getSigner(txn.sender);
-        switch (txn.type) {
-            case 'pay': {
-                const payment = this.buildPayment(txn, suggestedParams);
-                return [{ txn: payment, signer }];
-            }
-            case 'assetCreate': {
-                const assetCreate = this.buildAssetCreate(txn, suggestedParams);
-                return [{ txn: assetCreate, signer }];
-            }
-            case 'appCall': {
-                const appCall = this.buildAppCall(txn, suggestedParams);
-                return [{ txn: appCall, signer }];
-            }
-            case 'assetConfig': {
-                const assetConfig = this.buildAssetConfig(txn, suggestedParams);
-                return [{ txn: assetConfig, signer }];
-            }
-            case 'assetDestroy': {
-                const assetDestroy = this.buildAssetDestroy(txn, suggestedParams);
-                return [{ txn: assetDestroy, signer }];
-            }
-            case 'assetFreeze': {
-                const assetFreeze = this.buildAssetFreeze(txn, suggestedParams);
-                return [{ txn: assetFreeze, signer }];
-            }
-            case 'assetTransfer': {
-                const assetTransfer = this.buildAssetTransfer(txn, suggestedParams);
-                return [{ txn: assetTransfer, signer }];
-            }
-            case 'assetOptIn': {
-                const assetTransfer = this.buildAssetTransfer({ ...txn, receiver: txn.sender, amount: 0n }, suggestedParams);
-                return [{ txn: assetTransfer, signer }];
+        return (await this.buildTxn(txn, suggestedParams)).map((txn) => ({ txn, signer }));
+    }
+    /**
+     * 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
+     */
+    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)));
             }
-            case 'keyReg': {
-                const keyReg = this.buildKeyReg(txn, suggestedParams);
-                return [{ txn: keyReg, signer }];
+            else {
+                const transactionsWithSigner = txn.type === 'txnWithSigner'
+                    ? [txn]
+                    : txn.type === 'atc'
+                        ? this.buildAtc(txn.atc)
+                        : txn.type === 'methodCall'
+                            ? await this.buildMethodCall(txn, suggestedParams, false)
+                            : [];
+                transactions.push(...transactionsWithSigner.map((ts) => ts.txn));
+                transactionsWithSigner.forEach((ts, idx) => {
+                    if (ts.signer && ts.signer !== TransactionComposer.NULL_SIGNER) {
+                        signers.set(idx, ts.signer);
+                    }
+                });
             }
-            default:
-                throw Error(`Unsupported txn type`);
         }
+        for (let i = 0; i < transactions.length; i++) {
+            const method = this.txnMethodMap.get(transactions[i].txID());
+            if (method)
+                methodCalls.set(i, method);
+        }
+        return { transactions, methodCalls, signers };
+    }
+    /**
+     * Get 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 and the transactions
      */
     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.buildTxn(txn, suggestedParams)));
+                txnWithSigners.push(...(await this.buildTxnWithSigner(txn, suggestedParams)));
             }
-            txnWithSigners.forEach((ts) => {
-                this.atc.addTransaction(ts);
-            });
+            // Add all of the transactions to the underlying ATC
             const methodCalls = new Map();
             txnWithSigners.forEach((ts, idx) => {
+                this.atc.addTransaction(ts);
+                // Populate consolidated set of all ABI method calls
                 const method = this.txnMethodMap.get(ts.txn.txID());
                 if (method)
                     methodCalls.set(idx, method);
             });
             this.atc['methodCalls'] = methodCalls;
         }
-        return { atc: this.atc, transactions: this.atc.buildGroup() };
+        return { atc: this.atc, transactions: this.atc.buildGroup(), methodCalls: this.atc['methodCalls'] };
     }
     /**
      * Rebuild the group, discarding any previously built transactions.
@@ -446,24 +650,114 @@ class AlgokitComposer {
         return await this.build();
     }
     /**
-     * Compose the atomic transaction group and send it to the network
+     * Compose the atomic transaction group and send it to the network.
      * @param params The parameters to control execution with
      * @returns The execution result
      */
-    async execute(params) {
+    async send(params) {
         const group = (await this.build()).transactions;
         let waitRounds = params?.maxRoundsToWaitForConfirmation;
         if (waitRounds === undefined) {
-            const lastRound = group.reduce((max, txn) => Math.max(txn.txn.lastRound, max), 0);
-            const { firstRound } = await this.getSuggestedParams();
-            waitRounds = lastRound - firstRound + 1;
+            const lastRound = group.reduce((max, txn) => (txn.txn.lastValid > max ? txn.txn.lastValid : BigInt(max)), 0n);
+            const { firstValid: firstRound } = await this.getSuggestedParams();
+            waitRounds = Number(BigInt(lastRound) - BigInt(firstRound)) + 1;
         }
         return await transaction.sendAtomicTransactionComposer({
             atc: this.atc,
-            sendParams: { suppressLog: params?.suppressLog, maxRoundsToWaitForConfirmation: waitRounds },
+            suppressLog: params?.suppressLog,
+            maxRoundsToWaitForConfirmation: waitRounds,
+            populateAppCallResources: params?.populateAppCallResources,
         }, this.algod);
     }
+    /**
+     * @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);
+    }
+    /**
+     * Compose the atomic transaction group and simulate sending it to the network
+     * @returns The simulation result
+     */
+    async simulate(options) {
+        const atc = options?.skipSignatures ? new AtomicTransactionComposer() : this.atc;
+        // Build the transactions
+        if (options?.skipSignatures) {
+            options.allowEmptySignatures = true;
+            options.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: [],
+            ...options,
+            ...(config.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.Config.debug) {
+                await config.Config.events.emitAsync(types_lifecycleEvents.EventType.TxnGroupSimulated, { simulateResponse });
+            }
+            error.simulateResponse = simulateResponse;
+            throw error;
+        }
+        if (config.Config.debug && config.Config.traceAll) {
+            await config.Config.events.emitAsync(types_lifecycleEvents.EventType.TxnGroupSimulated, { simulateResponse });
+        }
+        const transactions = atc.buildGroup().map((t) => t.txn);
+        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(transaction.getABIReturnValue),
+        };
+    }
+    /**
+     * 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 : JSON.stringify(note.data)}`;
+        const encoder = new TextEncoder();
+        return encoder.encode(arc2Payload);
+    }
 }
+/** Signer used to represent a lack of signer */
+TransactionComposer.NULL_SIGNER = algosdk.makeEmptyTransactionSigner();
 
-module.exports = AlgokitComposer;
+exports.MAX_TRANSACTION_GROUP_SIZE = MAX_TRANSACTION_GROUP_SIZE;
+exports.TransactionComposer = TransactionComposer;
 //# sourceMappingURL=composer.js.map