@algorandfoundation/algokit-utils 8.1.0-beta.2 → 8.1.0-beta.4

package/types/composer.js

@@ -25,8 +25,10 @@ class TransactionComposer {
     constructor(params) {
         /** The ATC used to compose the group */
         this.atc = new algosdk.AtomicTransactionComposer();
-        /** Map of txid to ABI method */
-        this.txnMethodMap = new Map();
+        /** 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 */
@@ -250,11 +252,17 @@ class TransactionComposer {
         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 this was a method call return the ABIMethod for later
             if (atc['methodCalls'].get(idx)) {
-                this.txnMethodMap.set(ts.txn.txID(), atc['methodCalls'].get(idx));
+                return {
+                    ...ts,
+                    context: { abiMethod: atc['methodCalls'].get(idx) },
+                };
             }
-            return ts;
+            return {
+                ...ts,
+                context: {},
+            };
         });
         return txnWithSigners;
     }
@@ -297,7 +305,8 @@ class TransactionComposer {
         if (params.maxFee !== undefined && txn.fee > params.maxFee.microAlgo) {
             throw Error(`Transaction fee ${txn.fee} µALGO is greater than maxFee ${params.maxFee}`);
         }
-        return txn;
+        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.
@@ -353,7 +362,38 @@ class TransactionComposer {
             });
         }
         const methodAtc = new algosdk.AtomicTransactionComposer();
-        transactionsForGroup.reverse().forEach((txn) => methodAtc.addTransaction(txn));
+        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'
@@ -395,19 +435,37 @@ class TransactionComposer {
                         : params.signer
                     : this.getSigner(params.sender)
                 : TransactionComposer.NULL_SIGNER,
-            methodArgs: methodArgs.reverse(),
+            methodArgs: methodArgs
+                .map((arg) => {
+                if (typeof arg === 'object' && 'context' in arg) {
+                    const { context, ...txnWithSigner } = arg;
+                    return txnWithSigner;
+                }
+                return arg;
+            })
+                .reverse(),
             // note, lease, and rekeyTo are set in the common build step
             note: undefined,
             lease: undefined,
             rekeyTo: undefined,
         };
         // Build the transaction
-        this.commonTxnBuildStep((txnParams) => {
+        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);
+        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, {
@@ -568,7 +626,12 @@ class TransactionComposer {
     }
     async buildTxnWithSigner(txn, suggestedParams) {
         if (txn.type === 'txnWithSigner') {
-            return [txn];
+            return [
+                {
+                    ...txn,
+                    context: {},
+                },
+            ];
         }
         if (txn.type === 'atc') {
             return this.buildAtc(txn.atc);
@@ -577,7 +640,7 @@ class TransactionComposer {
             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) => ({ txn, signer }));
+        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.
@@ -591,7 +654,7 @@ class TransactionComposer {
         const signers = new Map();
         for (const txn of this.txns) {
             if (!['txnWithSigner', 'atc', 'methodCall'].includes(txn.type)) {
-                transactions.push(...(await this.buildTxn(txn, suggestedParams)));
+                transactions.push(...(await this.buildTxn(txn, suggestedParams)).map((txn) => txn.txn));
             }
             else {
                 const transactionsWithSigner = txn.type === 'txnWithSigner'
@@ -601,19 +664,17 @@ class TransactionComposer {
                         : txn.type === 'methodCall'
                             ? await this.buildMethodCall(txn, suggestedParams, false)
                             : [];
-                transactions.push(...transactionsWithSigner.map((ts) => ts.txn));
                 transactionsWithSigner.forEach((ts, idx) => {
+                    transactions.push(ts.txn);
                     if (ts.signer && ts.signer !== TransactionComposer.NULL_SIGNER) {
                         signers.set(idx, ts.signer);
                     }
+                    if ('context' in ts && ts.context.abiMethod) {
+                        methodCalls.set(idx, ts.context.abiMethod);
+                    }
                 });
             }
         }
-        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 };
     }
     /**
@@ -641,12 +702,15 @@ class TransactionComposer {
             }
             // Add all of the transactions to the underlying ATC
             const methodCalls = new Map();
-            txnWithSigners.forEach((ts, idx) => {
+            txnWithSigners.forEach(({ context, ...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);
+                if (context.abiMethod) {
+                    methodCalls.set(idx, context.abiMethod);
+                }
+                if (context.maxFee !== undefined) {
+                    this.txnMaxFees.set(idx, context.maxFee);
+                }
             });
             this.atc['methodCalls'] = methodCalls;
         }
@@ -669,9 +733,10 @@ class TransactionComposer {
     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 } = await this.getSuggestedParams();
+            const { firstValid: firstRound } = suggestedParams;
             waitRounds = Number(BigInt(lastRound) - BigInt(firstRound)) + 1;
         }
         return await transaction.sendAtomicTransactionComposer({
@@ -679,6 +744,13 @@ class TransactionComposer {
             suppressLog: params?.suppressLog,
             maxRoundsToWaitForConfirmation: waitRounds,
             populateAppCallResources: params?.populateAppCallResources,
+            coverAppCallInnerTransactionFees: params?.coverAppCallInnerTransactionFees,
+            additionalAtcContext: params?.coverAppCallInnerTransactionFees
+                ? {
+                    maxFees: this.txnMaxFees,
+                    suggestedParams: suggestedParams,
+                }
+                : undefined,
         }, this.algod);
     }
     /**