@algorandfoundation/algokit-utils 7.0.0-beta.9 → 8.0.0-beta.1

package/types/composer.mjs

@@ -1,21 +1,22 @@
-import algosdk from 'algosdk';
+import algosdk, { Address } from 'algosdk';
 import { Config } from '../config.mjs';
-import { performAtomicTransactionComposerSimulate } from '../transaction/perform-atomic-transaction-composer-simulate.mjs';
-import { encodeLease, sendAtomicTransactionComposer } from '../transaction/transaction.mjs';
+import { encodeLease, sendAtomicTransactionComposer, getABIReturnValue } from '../transaction/transaction.mjs';
 import { APP_PAGE_MAX_SIZE } from './app.mjs';
 import { AppManager } from './app-manager.mjs';
-import { EventType } from './async-event-emitter.mjs';
+import { EventType } from './lifecycle-events.mjs';
 import { genesisIdIsLocalNet } from './network-client.mjs';
 
 var AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
 var isTransactionWithSigner = algosdk.isTransactionWithSigner;
-var encodeAddress = algosdk.encodeAddress;
 var modelsv2 = algosdk.modelsv2;
+const address = (address) => {
+    return typeof address === 'string' ? Address.fromString(address) : address;
+};
 const MAX_TRANSACTION_GROUP_SIZE = 16;
-/** AlgoKit Composer helps you compose and execute transactions as a transaction group. */
-class AlgoKitComposer {
+/** 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) {
@@ -26,7 +27,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;
@@ -46,7 +47,7 @@ class AlgoKitComposer {
     addTransaction(transaction, signer) {
         this.txns.push({
             txn: transaction,
-            signer: signer ?? this.getSigner(algosdk.encodeAddress(transaction.from.publicKey)),
+            signer: signer ?? this.getSigner(transaction.sender),
             type: 'txnWithSigner',
         });
         return this;
@@ -222,6 +223,15 @@ class AlgoKitComposer {
         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
+     */
+    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
@@ -232,13 +242,11 @@ class AlgoKitComposer {
         return this;
     }
     /** Build an ATC and return transactions ready to be incorporated into a broader set of transactions this composer is composing */
-    buildAtc(atc, processTransaction) {
+    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 AlgoKitComposer is built
+            // Remove underlying group ID from the transaction since it will be re-grouped when this TransactionComposer is built
             ts.txn.group = undefined;
-            // Process transaction if a function is provided
-            ts.txn = processTransaction?.(ts.txn, idx) ?? ts.txn;
             // 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));
@@ -247,39 +255,42 @@ class AlgoKitComposer {
         });
         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(encodeLease(params.lease));
+            txnParams.lease = encodeLease(params.lease);
         if (params.rekeyTo)
-            txn.addRekey(params.rekeyTo);
+            txnParams.rekeyTo = address(params.rekeyTo);
         const encoder = new TextEncoder();
         if (params.note)
-            txn.note = typeof params.note === 'string' ? encoder.encode(params.note) : 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 && genesisIdIsLocalNet(suggestedParams.genesisID) ? 1000 : this.defaultValidityWindow);
-            txn.lastRound = txn.firstRound + window;
+            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) {
-            txn.fee = Number(params.staticFee.microAlgo);
-        }
-        else {
-            txn.fee = txn.estimateSize() * suggestedParams.fee || algosdk.ALGORAND_MIN_TX_FEE;
-            if (params.extraFee)
-                txn.fee += Number(params.extraFee.microAlgo);
+            txnParams.suggestedParams.fee = params.staticFee.microAlgo;
+            txnParams.suggestedParams.flatFee = true;
         }
-        txn.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}`);
         }
@@ -292,14 +303,22 @@ class AlgoKitComposer {
      */
     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;
         };
-        for (let i = 0; i < (params.args ?? []).length; i++) {
+        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)) {
@@ -312,7 +331,10 @@ class AlgoKitComposer {
             }
             if ('method' in arg) {
                 const tempTxnWithSigners = await this.buildMethodCall(arg, suggestedParams, includeSigner);
-                methodArgs.push(...tempTxnWithSigners);
+                // 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;
@@ -323,11 +345,12 @@ class AlgoKitComposer {
                         ? 'signer' in params.signer
                             ? params.signer.signer
                             : params.signer
-                        : this.getSigner(encodeAddress(txn.from.publicKey))
-                    : AlgoKitComposer.NULL_SIGNER,
+                        : this.getSigner(txn.sender)
+                    : TransactionComposer.NULL_SIGNER,
             });
         }
         const methodAtc = new algosdk.AtomicTransactionComposer();
+        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'
@@ -339,7 +362,7 @@ class AlgoKitComposer {
                 ? (await this.appManager.compileTeal(params.clearStateProgram)).compiledBase64ToBytes
                 : params.clearStateProgram
             : undefined;
-        methodAtc.addMethodCall({
+        const txnParams = {
             appID: appId,
             sender: params.sender,
             suggestedParams,
@@ -357,10 +380,10 @@ class AlgoKitComposer {
                         ? Math.floor((approvalProgram.length + (clearStateProgram?.length ?? 0)) / 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,
+            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
@@ -368,49 +391,51 @@ class AlgoKitComposer {
                         ? params.signer.signer
                         : params.signer
                     : this.getSigner(params.sender)
-                : AlgoKitComposer.NULL_SIGNER,
-            methodArgs: methodArgs,
+                : TransactionComposer.NULL_SIGNER,
+            methodArgs: methodArgs.reverse(),
             // note, lease, and rekeyTo are set in the common build step
             note: undefined,
             lease: undefined,
             rekeyTo: undefined,
-        });
+        };
+        // 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
-        //  and with the common build step to set fees and validity rounds
-        return this.buildAtc(methodAtc, (txn, idx) => idx === methodAtc.count() - 1 ? this.commonTxnBuildStep(params, txn, suggestedParams) : txn);
+        return this.buildAtc(methodAtc);
     }
     buildPayment(params, suggestedParams) {
-        const txn = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
-            from: params.sender,
-            to: params.receiver,
+        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,
@@ -418,40 +443,36 @@ 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);
     }
     async buildAppCall(params, suggestedParams) {
-        const appId = Number('appId' in params ? params.appId : 0n);
+        const appId = 'appId' in params ? params.appId : 0n;
         const approvalProgram = 'approvalProgram' in params
             ? typeof params.approvalProgram === 'string'
                 ? (await this.appManager.compileTeal(params.approvalProgram)).compiledBase64ToBytes
@@ -463,7 +484,7 @@ class AlgoKitComposer {
                 : params.clearStateProgram
             : undefined;
         const sdkParams = {
-            from: params.sender,
+            sender: params.sender,
             suggestedParams,
             appArgs: params.args,
             onComplete: params.onComplete ?? algosdk.OnApplicationComplete.NoOpOC,
@@ -474,32 +495,46 @@ class AlgoKitComposer {
             approvalProgram,
             clearProgram: clearStateProgram,
         };
-        let txn;
-        if (appId === 0) {
+        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,
                 extraPages: 'extraProgramPages' in params
-                    ? params.extraProgramPages ?? Math.floor((approvalProgram.length + clearStateProgram.length) / APP_PAGE_MAX_SIZE)
+                    ? (params.extraProgramPages ?? Math.floor((approvalProgram.length + clearStateProgram.length) / 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,
+                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 {
-            txn = algosdk.makeApplicationCallTxnFromObject({ ...sdkParams, appIndex: appId });
+            return this.commonTxnBuildStep(algosdk.makeApplicationCallTxnFromObject, params, { ...sdkParams, appIndex: appId });
         }
-        return this.commonTxnBuildStep(params, txn, suggestedParams);
     }
     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);
+        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) {
@@ -565,7 +600,7 @@ class AlgoKitComposer {
                             : [];
                 transactions.push(...transactionsWithSigner.map((ts) => ts.txn));
                 transactionsWithSigner.forEach((ts, idx) => {
-                    if (ts.signer && ts.signer !== AlgoKitComposer.NULL_SIGNER) {
+                    if (ts.signer && ts.signer !== TransactionComposer.NULL_SIGNER) {
                         signers.set(idx, ts.signer);
                     }
                 });
@@ -632,9 +667,9 @@ class AlgoKitComposer {
         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 sendAtomicTransactionComposer({
             atc: this.atc,
@@ -664,10 +699,11 @@ class AlgoKitComposer {
         // 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: AlgoKitComposer.NULL_SIGNER });
+                atc.addTransaction({ txn, signer: TransactionComposer.NULL_SIGNER });
             }
             atc['methodCalls'] = transactions.methodCalls;
         }
@@ -675,21 +711,36 @@ class AlgoKitComposer {
             // Build creates real signatures
             await this.build();
         }
-        if (Config.debug && !Config.traceAll) {
-            // Dump the traces to a file for use with AlgoKit AVM debugger
-            // Checks for false on traceAll because it should have been already
-            // executed above
-            const simulateResponse = await performAtomicTransactionComposerSimulate(atc, this.algod);
-            await Config.events.emitAsync(EventType.TxnGroupSimulated, {
-                simulateResponse,
-            });
-        }
-        const { methodResults, simulateResponse } = await atc.simulate(this.algod, new modelsv2.SimulateRequest({ txnGroups: [], ...options }));
-        if (simulateResponse && simulateResponse.txnGroups[0].failedAt) {
-            const error = new Error(`Transaction failed at transaction(s) ${simulateResponse.txnGroups[0].failedAt.join(', ')} in the group. ${simulateResponse.txnGroups.find((x) => x.failureMessage)?.failureMessage}`);
+        const { methodResults, simulateResponse } = await atc.simulate(this.algod, new modelsv2.SimulateRequest({
+            txnGroups: [],
+            ...options,
+            ...(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 });
+            }
             error.simulateResponse = simulateResponse;
             throw error;
         }
+        if (Config.debug && Config.traceAll) {
+            await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateResponse });
+        }
         const transactions = atc.buildGroup().map((t) => t.txn);
         return {
             confirmations: simulateResponse.txnGroups[0].txnResults.map((t) => t.txnResult),
@@ -697,7 +748,7 @@ class AlgoKitComposer {
             txIds: transactions.map((t) => t.txID()),
             groupId: Buffer.from(transactions[0].group ?? new Uint8Array()).toString('base64'),
             simulateResponse,
-            returns: methodResults.map((m) => m),
+            returns: methodResults.map(getABIReturnValue),
         };
     }
     /**
@@ -714,7 +765,7 @@ class AlgoKitComposer {
     }
 }
 /** Signer used to represent a lack of signer */
-AlgoKitComposer.NULL_SIGNER = algosdk.makeEmptyTransactionSigner();
+TransactionComposer.NULL_SIGNER = algosdk.makeEmptyTransactionSigner();
 
-export { MAX_TRANSACTION_GROUP_SIZE, AlgoKitComposer as default };
+export { MAX_TRANSACTION_GROUP_SIZE, TransactionComposer };
 //# sourceMappingURL=composer.mjs.map