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

package/transaction/transaction.js

@@ -3,17 +3,16 @@
 var algosdk = require('algosdk');
 var buffer = require('buffer');
 var config = require('../config.js');
-var types_asyncEventEmitter = require('../types/async-event-emitter.js');
+var types_lifecycleEvents = require('../types/lifecycle-events.js');
 var util = require('../util.js');
 var performAtomicTransactionComposerSimulate = require('./perform-atomic-transaction-composer-simulate.js');
 
 var AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
-var modelsv2 = algosdk.modelsv2;
 const MAX_TRANSACTION_GROUP_SIZE = 16;
 const MAX_APP_CALL_FOREIGN_REFERENCES = 8;
 const MAX_APP_CALL_ACCOUNT_REFERENCES = 4;
 /**
- * @deprecated Convert your data to a `string` or `Uint8Array`, if using ARC-2 use `AlgoKitComposer.arc2Note`.
+ * @deprecated Convert your data to a `string` or `Uint8Array`, if using ARC-2 use `TransactionComposer.arc2Note`.
  *
  * Encodes a transaction note into a byte array ready to be included in an Algorand transaction.
  *
@@ -89,10 +88,10 @@ function encodeLease(lease) {
  * @returns The public address
  */
 const getSenderAddress = function (sender) {
-    return typeof sender === 'string' ? sender : 'addr' in sender ? sender.addr : sender.address();
+    return typeof sender === 'string' ? sender : 'addr' in sender ? sender.addr.toString() : sender.address().toString();
 };
 /**
- * @deprecated Use `AlgorandClient` / `AlgoKitComposer` to construct transactions instead or
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to construct transactions instead or
  * construct an `algosdk.TransactionWithSigner` manually instead.
  *
  * Given a transaction in a variety of supported formats, returns a TransactionWithSigner object ready to be passed to an
@@ -149,7 +148,7 @@ const getSenderTransactionSigner = memoize(function (sender) {
             : algosdk.makeBasicAccountTransactionSigner(sender);
 });
 /**
- * @deprecated Use `AlgorandClient` / `AlgoKitComposer` to sign transactions
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to sign transactions
  * or use the relevant underlying `account.signTxn` / `algosdk.signLogicSigTransactionObject`
  * / `multiSigAccount.sign` / `TransactionSigner` methods directly.
  *
@@ -168,7 +167,7 @@ const signTransaction = async (transaction, signer) => {
                 : (await signer.signer([transaction], [0]))[0];
 };
 /**
- * @deprecated Use `AlgorandClient` / `AlgoKitComposer` to send transactions.
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to send transactions.
  *
  * Prepares a transaction for sending and then (if instructed) signs and sends the given transaction to the chain.
  *
@@ -218,29 +217,18 @@ const sendTransaction = async function (send, algod) {
  * @returns The unnamed resources accessed by the group and by each transaction in the group
  */
 async function getUnnamedAppCallResourcesAccessed(atc, algod) {
-    const simReq = new algosdk.modelsv2.SimulateRequest({
+    const simulateRequest = new algosdk.modelsv2.SimulateRequest({
         txnGroups: [],
         allowUnnamedResources: true,
         allowEmptySignatures: true,
+        fixSigners: true,
     });
-    const signerWithFixedSgnr = async (txns, indexes) => {
-        const stxns = await algosdk.makeEmptyTransactionSigner()(txns, indexes);
-        return Promise.all(stxns.map(async (stxn) => {
-            const decodedStxn = algosdk.decodeSignedTransaction(stxn);
-            const sender = algosdk.encodeAddress(decodedStxn.txn.from.publicKey);
-            const authAddr = (await algod.accountInformation(sender).do())['auth-addr'];
-            const stxnObj = { txn: decodedStxn.txn.get_obj_for_encoding() };
-            if (authAddr !== undefined) {
-                stxnObj.sgnr = buffer.Buffer.from(algosdk.decodeAddress(authAddr).publicKey);
-            }
-            return algosdk.encodeObj(stxnObj);
-        }));
-    };
+    const nullSigner = algosdk.makeEmptyTransactionSigner();
     const emptySignerAtc = atc.clone();
     emptySignerAtc['transactions'].forEach((t) => {
-        t.signer = signerWithFixedSgnr;
+        t.signer = nullSigner;
     });
-    const result = await emptySignerAtc.simulate(algod, simReq);
+    const result = await emptySignerAtc.simulate(algod, simulateRequest);
     const groupResponse = result.simulateResponse.txnGroups[0];
     if (groupResponse.failureMessage) {
         throw Error(`Error during resource population simulation in transaction ${groupResponse.failedAt}: ${groupResponse.failureMessage}`);
@@ -273,7 +261,7 @@ async function populateAppCallResources(atc, algod) {
     const unnamedResourcesAccessed = await getUnnamedAppCallResourcesAccessed(atc, algod);
     const group = atc.buildGroup();
     unnamedResourcesAccessed.txns.forEach((r, i) => {
-        if (r === undefined)
+        if (r === undefined || group[i].txn.type !== algosdk.TransactionType.appl)
             return;
         if (r.boxes || r.extraBoxRefs)
             throw Error('Unexpected boxes at the transaction level');
@@ -281,22 +269,19 @@ async function populateAppCallResources(atc, algod) {
             throw Error('Unexpected app local at the transaction level');
         if (r.assetHoldings)
             throw Error('Unexpected asset holding at the transaction level');
-        // Do accounts first because the account limit is 4
-        r.accounts?.forEach((a) => {
-            group[i].txn.appAccounts = [...(group[i].txn.appAccounts ?? []), algosdk.decodeAddress(a)];
-        });
-        r.apps?.forEach((a) => {
-            group[i].txn.appForeignApps = [...(group[i].txn.appForeignApps ?? []), Number(a)];
-        });
-        r.assets?.forEach((a) => {
-            group[i].txn.appForeignAssets = [...(group[i].txn.appForeignAssets ?? []), Number(a)];
-        });
-        const accounts = group[i].txn.appAccounts?.length || 0;
+        group[i].txn['applicationCall'] = {
+            ...group[i].txn.applicationCall,
+            accounts: [...(group[i].txn?.applicationCall?.accounts ?? []), ...(r.accounts ?? [])],
+            foreignApps: [...(group[i].txn?.applicationCall?.foreignApps ?? []), ...(r.apps ?? [])],
+            foreignAssets: [...(group[i].txn?.applicationCall?.foreignAssets ?? []), ...(r.assets ?? [])],
+            boxes: [...(group[i].txn?.applicationCall?.boxes ?? []), ...(r.boxes ?? [])],
+        };
+        const accounts = group[i].txn.applicationCall?.accounts?.length ?? 0;
         if (accounts > MAX_APP_CALL_ACCOUNT_REFERENCES)
             throw Error(`Account reference limit of ${MAX_APP_CALL_ACCOUNT_REFERENCES} exceeded in transaction ${i}`);
-        const assets = group[i].txn.appForeignAssets?.length || 0;
-        const apps = group[i].txn.appForeignApps?.length || 0;
-        const boxes = group[i].txn.boxes?.length || 0;
+        const assets = group[i].txn.applicationCall?.foreignAssets?.length ?? 0;
+        const apps = group[i].txn.applicationCall?.foreignApps?.length ?? 0;
+        const boxes = group[i].txn.applicationCall?.boxes?.length ?? 0;
         if (accounts + assets + apps + boxes > MAX_APP_CALL_FOREIGN_REFERENCES) {
             throw Error(`Resource reference limit of ${MAX_APP_CALL_FOREIGN_REFERENCES} exceeded in transaction ${i}`);
         }
@@ -305,10 +290,10 @@ async function populateAppCallResources(atc, algod) {
         const isApplBelowLimit = (t) => {
             if (t.txn.type !== algosdk.TransactionType.appl)
                 return false;
-            const accounts = t.txn.appAccounts?.length || 0;
-            const assets = t.txn.appForeignAssets?.length || 0;
-            const apps = t.txn.appForeignApps?.length || 0;
-            const boxes = t.txn.boxes?.length || 0;
+            const accounts = t.txn.applicationCall?.accounts?.length ?? 0;
+            const assets = t.txn.applicationCall?.foreignAssets?.length ?? 0;
+            const apps = t.txn.applicationCall?.foreignApps?.length ?? 0;
+            const boxes = t.txn.applicationCall?.boxes?.length ?? 0;
             return accounts + assets + apps + boxes < MAX_APP_CALL_FOREIGN_REFERENCES;
         };
         // If this is a asset holding or app local, first try to find a transaction that already has the account available
@@ -319,22 +304,26 @@ async function populateAppCallResources(atc, algod) {
                     return false;
                 return (
                 // account is in the foreign accounts array
-                t.txn.appAccounts?.map((a) => algosdk.encodeAddress(a.publicKey)).includes(account) ||
+                t.txn.applicationCall?.accounts?.map((a) => a.toString()).includes(account.toString()) ||
                     // account is available as an app account
-                    t.txn.appForeignApps?.map((a) => algosdk.getApplicationAddress(a)).includes(account) ||
+                    t.txn.applicationCall?.foreignApps?.map((a) => algosdk.getApplicationAddress(a).toString()).includes(account.toString()) ||
                     // account is available since it's in one of the fields
-                    Object.values(t.txn)
-                        .map((f) => JSON.stringify(f))
-                        .includes(JSON.stringify(algosdk.decodeAddress(account))));
+                    Object.values(t.txn).some((f) => algosdk.stringifyJSON(f, (_, v) => (v instanceof algosdk.Address ? v.toString() : v))?.includes(account.toString())));
             });
             if (txnIndex > -1) {
                 if (type === 'assetHolding') {
                     const { asset } = reference;
-                    txns[txnIndex].txn.appForeignAssets = [...(txns[txnIndex].txn.appForeignAssets ?? []), Number(asset)];
+                    txns[txnIndex].txn['applicationCall'] = {
+                        ...txns[txnIndex].txn.applicationCall,
+                        foreignAssets: [...(txns[txnIndex].txn?.applicationCall?.foreignAssets ?? []), ...[asset]],
+                    };
                 }
                 else {
                     const { app } = reference;
-                    txns[txnIndex].txn.appForeignApps = [...(txns[txnIndex].txn.appForeignApps ?? []), Number(app)];
+                    txns[txnIndex].txn['applicationCall'] = {
+                        ...txns[txnIndex].txn.applicationCall,
+                        foreignApps: [...(txns[txnIndex].txn?.applicationCall?.foreignApps ?? []), ...[app]],
+                    };
                 }
                 return;
             }
@@ -343,20 +332,23 @@ async function populateAppCallResources(atc, algod) {
                 if (!isApplBelowLimit(t))
                     return false;
                 // check if there is space in the accounts array
-                if ((t.txn.appAccounts?.length || 0) >= MAX_APP_CALL_ACCOUNT_REFERENCES)
+                if ((t.txn.applicationCall?.accounts?.length ?? 0) >= MAX_APP_CALL_ACCOUNT_REFERENCES)
                     return false;
                 if (type === 'assetHolding') {
                     const { asset } = reference;
-                    return t.txn.appForeignAssets?.includes(Number(asset));
+                    return t.txn.applicationCall?.foreignAssets?.includes(asset);
                 }
                 else {
                     const { app } = reference;
-                    return t.txn.appForeignApps?.includes(Number(app)) || t.txn.appIndex === Number(app);
+                    return t.txn.applicationCall?.foreignApps?.includes(app) || t.txn.applicationCall?.appIndex === app;
                 }
             });
             if (txnIndex > -1) {
                 const { account } = reference;
-                txns[txnIndex].txn.appAccounts = [...(txns[txnIndex].txn.appAccounts ?? []), algosdk.decodeAddress(account)];
+                txns[txnIndex].txn['applicationCall'] = {
+                    ...txns[txnIndex].txn.applicationCall,
+                    accounts: [...(txns[txnIndex].txn?.applicationCall?.accounts ?? []), ...[account]],
+                };
                 return;
             }
         }
@@ -367,10 +359,13 @@ async function populateAppCallResources(atc, algod) {
                 if (!isApplBelowLimit(t))
                     return false;
                 // If the app is in the foreign array OR the app being called, then we know it's available
-                return t.txn.appForeignApps?.includes(Number(app)) || t.txn.appIndex === Number(app);
+                return t.txn.applicationCall?.foreignApps?.includes(app) || t.txn.applicationCall?.appIndex === app;
             });
             if (txnIndex > -1) {
-                txns[txnIndex].txn.boxes = [...(txns[txnIndex].txn.boxes ?? []), { appIndex: Number(app), name }];
+                txns[txnIndex].txn['applicationCall'] = {
+                    ...txns[txnIndex].txn.applicationCall,
+                    boxes: [...(txns[txnIndex].txn?.applicationCall?.boxes ?? []), ...[{ appIndex: app, name }]],
+                };
                 return;
             }
         }
@@ -378,12 +373,12 @@ async function populateAppCallResources(atc, algod) {
         const txnIndex = txns.findIndex((t) => {
             if (t.txn.type !== algosdk.TransactionType.appl)
                 return false;
-            const accounts = t.txn.appAccounts?.length || 0;
+            const accounts = t.txn.applicationCall?.accounts?.length ?? 0;
             if (type === 'account')
                 return accounts < MAX_APP_CALL_ACCOUNT_REFERENCES;
-            const assets = t.txn.appForeignAssets?.length || 0;
-            const apps = t.txn.appForeignApps?.length || 0;
-            const boxes = t.txn.boxes?.length || 0;
+            const assets = t.txn.applicationCall?.foreignAssets?.length ?? 0;
+            const apps = t.txn.applicationCall?.foreignApps?.length ?? 0;
+            const boxes = t.txn.applicationCall?.boxes?.length ?? 0;
             // If we're adding local state or asset holding, we need space for the acocunt and the other reference
             if (type === 'assetHolding' || type === 'appLocal') {
                 return accounts + assets + apps + boxes < MAX_APP_CALL_FOREIGN_REFERENCES - 1 && accounts < MAX_APP_CALL_ACCOUNT_REFERENCES;
@@ -398,30 +393,57 @@ async function populateAppCallResources(atc, algod) {
             throw Error('No more transactions below reference limit. Add another app call to the group.');
         }
         if (type === 'account') {
-            txns[txnIndex].txn.appAccounts = [...(txns[txnIndex].txn.appAccounts ?? []), algosdk.decodeAddress(reference)];
+            txns[txnIndex].txn['applicationCall'] = {
+                ...txns[txnIndex].txn.applicationCall,
+                accounts: [...(txns[txnIndex].txn?.applicationCall?.accounts ?? []), ...[reference]],
+            };
         }
         else if (type === 'app') {
-            txns[txnIndex].txn.appForeignApps = [...(txns[txnIndex].txn.appForeignApps ?? []), Number(reference)];
+            txns[txnIndex].txn['applicationCall'] = {
+                ...txns[txnIndex].txn.applicationCall,
+                foreignApps: [
+                    ...(txns[txnIndex].txn?.applicationCall?.foreignApps ?? []),
+                    ...[typeof reference === 'bigint' ? reference : BigInt(reference)],
+                ],
+            };
         }
         else if (type === 'box') {
             const { app, name } = reference;
-            txns[txnIndex].txn.boxes = [...(txns[txnIndex].txn.boxes ?? []), { appIndex: Number(app), name }];
+            txns[txnIndex].txn['applicationCall'] = {
+                ...txns[txnIndex].txn.applicationCall,
+                boxes: [...(txns[txnIndex].txn?.applicationCall?.boxes ?? []), ...[{ appIndex: app, name }]],
+            };
             if (app.toString() !== '0') {
-                txns[txnIndex].txn.appForeignApps = [...(txns[txnIndex].txn.appForeignApps ?? []), Number(app)];
+                txns[txnIndex].txn['applicationCall'] = {
+                    ...txns[txnIndex].txn.applicationCall,
+                    foreignApps: [...(txns[txnIndex].txn?.applicationCall?.foreignApps ?? []), ...[app]],
+                };
             }
         }
         else if (type === 'assetHolding') {
             const { asset, account } = reference;
-            txns[txnIndex].txn.appForeignAssets = [...(txns[txnIndex].txn.appForeignAssets ?? []), Number(asset)];
-            txns[txnIndex].txn.appAccounts = [...(txns[txnIndex].txn.appAccounts ?? []), algosdk.decodeAddress(account)];
+            txns[txnIndex].txn['applicationCall'] = {
+                ...txns[txnIndex].txn.applicationCall,
+                foreignAssets: [...(txns[txnIndex].txn?.applicationCall?.foreignAssets ?? []), ...[asset]],
+                accounts: [...(txns[txnIndex].txn?.applicationCall?.accounts ?? []), ...[account]],
+            };
         }
         else if (type === 'appLocal') {
             const { app, account } = reference;
-            txns[txnIndex].txn.appAccounts = [...(txns[txnIndex].txn.appAccounts ?? []), algosdk.decodeAddress(account)];
-            txns[txnIndex].txn.appForeignApps = [...(txns[txnIndex].txn.appForeignApps ?? []), Number(app)];
+            txns[txnIndex].txn['applicationCall'] = {
+                ...txns[txnIndex].txn.applicationCall,
+                foreignApps: [...(txns[txnIndex].txn?.applicationCall?.foreignApps ?? []), ...[app]],
+                accounts: [...(txns[txnIndex].txn?.applicationCall?.accounts ?? []), ...[account]],
+            };
         }
         else if (type === 'asset') {
-            txns[txnIndex].txn.appForeignAssets = [...(txns[txnIndex].txn.appForeignAssets ?? []), Number(reference)];
+            txns[txnIndex].txn['applicationCall'] = {
+                ...txns[txnIndex].txn.applicationCall,
+                foreignAssets: [
+                    ...(txns[txnIndex].txn?.applicationCall?.foreignAssets ?? []),
+                    ...[typeof reference === 'bigint' ? reference : BigInt(reference)],
+                ],
+            };
         }
     };
     const g = unnamedResourcesAccessed.group;
@@ -480,20 +502,14 @@ async function populateAppCallResources(atc, algod) {
 const sendAtomicTransactionComposer = async function (atcSend, algod) {
     const { atc: givenAtc, sendParams, ...executeParams } = atcSend;
     let atc;
-    // const hasAppCalls = () =>
-    //   givenAtc
-    //     .buildGroup()
-    //     .map((t) => t.txn.type)
-    //     .includes(algosdk.TransactionType.appl)
     atc = givenAtc;
     try {
+        const transactionsWithSigner = atc.buildGroup();
         // If populateAppCallResources is true OR if populateAppCallResources is undefined and there are app calls, then populate resources
-        // NOTE: Temporary false by default until this algod bug is fixed: https://github.com/algorand/go-algorand/issues/5914
         const populateResources = executeParams?.populateAppCallResources ?? sendParams?.populateAppCallResources ?? config.Config.populateAppCallResources;
-        if (populateResources) {
+        if (populateResources && transactionsWithSigner.map((t) => t.txn.type).includes(algosdk.TransactionType.appl)) {
             atc = await populateAppCallResources(givenAtc, algod);
         }
-        const transactionsWithSigner = atc.buildGroup();
         const transactionsToSend = transactionsWithSigner.map((t) => {
             return t.txn;
         });
@@ -508,7 +524,7 @@ const sendAtomicTransactionComposer = async function (atcSend, algod) {
         if (config.Config.debug && config.Config.traceAll) {
             // Dump the traces to a file for use with AlgoKit AVM debugger
             const simulateResponse = await performAtomicTransactionComposerSimulate.performAtomicTransactionComposerSimulate(atc, algod);
-            await config.Config.events.emitAsync(types_asyncEventEmitter.EventType.TxnGroupSimulated, {
+            await config.Config.events.emitAsync(types_lifecycleEvents.EventType.TxnGroupSimulated, {
                 simulateResponse,
             });
         }
@@ -517,22 +533,18 @@ const sendAtomicTransactionComposer = async function (atcSend, algod) {
             config.Config.getLogger(executeParams?.suppressLog ?? sendParams?.suppressLog).verbose(`Group transaction (${groupId}) sent with ${transactionsToSend.length} transactions`);
         }
         else {
-            config.Config.getLogger(executeParams?.suppressLog ?? sendParams?.suppressLog).verbose(`Sent transaction ID ${transactionsToSend[0].txID()} ${transactionsToSend[0].type} from ${algosdk.encodeAddress(transactionsToSend[0].from.publicKey)}`);
+            config.Config.getLogger(executeParams?.suppressLog ?? sendParams?.suppressLog).verbose(`Sent transaction ID ${transactionsToSend[0].txID()} ${transactionsToSend[0].type} from ${transactionsToSend[0].sender.toString()}`);
         }
         let confirmations = undefined;
         if (!sendParams?.skipWaiting) {
-            confirmations = await Promise.all(transactionsToSend.map(async (t) => modelsv2.PendingTransactionResponse.from_obj_for_encoding(await algod.pendingTransactionInformation(t.txID()).do())));
+            confirmations = await Promise.all(transactionsToSend.map(async (t) => await algod.pendingTransactionInformation(t.txID()).do()));
         }
         return {
             groupId,
             confirmations,
             txIds: transactionsToSend.map((t) => t.txID()),
             transactions: transactionsToSend,
-            returns: result.methodResults.map((r) => ({
-                decodeError: r.decodeError,
-                returnValue: r.returnValue,
-                rawReturnValue: r.rawReturnValue,
-            })),
+            returns: result.methodResults.map(getABIReturnValue),
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
     }
@@ -545,6 +557,9 @@ const sendAtomicTransactionComposer = async function (atcSend, algod) {
             // Remove headers as it doesn't have anything useful.
             delete e.response?.headers;
             err.response = e.response;
+            // body property very noisy
+            if (e.response && 'body' in e.response)
+                delete err.response.body;
             err.name = e.name;
         }
         if (config.Config.debug && typeof e === 'object') {
@@ -552,14 +567,15 @@ const sendAtomicTransactionComposer = async function (atcSend, algod) {
             config.Config.logger.error('Received error executing Atomic Transaction Composer and debug flag enabled; attempting simulation to get more information', err);
             const simulate = await performAtomicTransactionComposerSimulate.performAtomicTransactionComposerSimulate(atc, algod);
             if (config.Config.debug && !config.Config.traceAll) {
-                await config.Config.events.emitAsync(types_asyncEventEmitter.EventType.TxnGroupSimulated, {
+                // Emit the event only if traceAll: false, as it should have already been emitted above
+                await config.Config.events.emitAsync(types_lifecycleEvents.EventType.TxnGroupSimulated, {
                     simulateResponse: simulate,
                 });
             }
             if (simulate && simulate.txnGroups[0].failedAt) {
                 for (const txn of simulate.txnGroups[0].txnResults) {
                     err.traces.push({
-                        trace: txn.execTrace?.get_obj_for_encoding(),
+                        trace: txn.execTrace?.toEncodingData(),
                         appBudget: txn.appBudgetConsumed,
                         logicSigBudget: txn.logicSigBudgetConsumed,
                         logs: txn.txnResult.logs,
@@ -574,24 +590,47 @@ const sendAtomicTransactionComposer = async function (atcSend, algod) {
         throw err;
     }
 };
+const convertABIDecodedBigIntToNumber = (value, type) => {
+    if (typeof value === 'bigint') {
+        if (type instanceof algosdk.ABIUintType) {
+            return type.bitSize < 53 ? Number(value) : value;
+        }
+        else {
+            return value;
+        }
+    }
+    else if (Array.isArray(value) && (type instanceof algosdk.ABIArrayStaticType || type instanceof algosdk.ABIArrayDynamicType)) {
+        return value.map((v) => convertABIDecodedBigIntToNumber(v, type.childType));
+    }
+    else if (Array.isArray(value) && type instanceof algosdk.ABITupleType) {
+        return value.map((v, i) => convertABIDecodedBigIntToNumber(v, type.childTypes[i]));
+    }
+    else {
+        return value;
+    }
+};
 /**
- * @deprecated Use `performAtomicTransactionComposerSimulate`, dry-run is a deprecated Algorand feature.
- *
- * Performs a dry run of the transactions loaded into the given AtomicTransactionComposer`
- * @param atc The AtomicTransactionComposer` with transaction(s) loaded
- * @param algod An Algod client
- * @returns The dryrun result
+ * Takes an algosdk `ABIResult` and converts it to an `ABIReturn`.
+ * Converts `bigint`'s for Uint's < 64 to `number` for easier use.
+ * @param result The `ABIReturn`
  */
-async function performAtomicTransactionComposerDryrun(atc, algod) {
-    const signedTransactions = await atc.gatherSignatures();
-    const txns = signedTransactions.map((t) => {
-        return algosdk.decodeSignedTransaction(t);
-    });
-    const dryrun = await algosdk.createDryrun({ client: algod, txns });
-    return new algosdk.DryrunResult(await algod.dryrun(dryrun).do());
+function getABIReturnValue(result) {
+    if (result.decodeError) {
+        return {
+            decodeError: result.decodeError,
+        };
+    }
+    return {
+        method: result.method,
+        rawReturnValue: result.rawReturnValue,
+        decodeError: undefined,
+        returnValue: result.returnValue !== undefined && result.method.returns.type !== 'void'
+            ? convertABIDecodedBigIntToNumber(result.returnValue, result.method.returns.type)
+            : result.returnValue,
+    };
 }
 /**
- * @deprecated Use `AlgoKitComposer` (`algorand.newGroup()`) or `AtomicTransactionComposer` to construct and send group transactions instead.
+ * @deprecated Use `TransactionComposer` (`algorand.newGroup()`) or `AtomicTransactionComposer` to construct and send group transactions instead.
  *
  * Signs and sends a group of [up to 16](https://developer.algorand.org/docs/get-details/atomic_transfers/#create-transactions) transactions to the chain
  *
@@ -642,7 +681,7 @@ const waitForConfirmation = async function (transactionId, maxRoundsToWait, algo
         throw new Error(`Invalid timeout, received ${maxRoundsToWait}, expected > 0`);
     }
     // Get current round
-    const status = modelsv2.NodeStatusResponse.from_obj_for_encoding(await algod.status().do());
+    const status = await algod.status().do();
     if (status === undefined) {
         throw new Error('Unable to get node status');
     }
@@ -651,7 +690,7 @@ const waitForConfirmation = async function (transactionId, maxRoundsToWait, algo
     let currentRound = startRound;
     while (currentRound < startRound + BigInt(maxRoundsToWait)) {
         try {
-            const pendingInfo = modelsv2.PendingTransactionResponse.from_obj_for_encoding(await algod.pendingTransactionInformation(transactionId).do());
+            const pendingInfo = await algod.pendingTransactionInformation(transactionId).do();
             if (pendingInfo !== undefined) {
                 const confirmedRound = pendingInfo.confirmedRound;
                 if (confirmedRound && confirmedRound > 0) {
@@ -679,7 +718,7 @@ const waitForConfirmation = async function (transactionId, maxRoundsToWait, algo
     throw new Error(`Transaction ${transactionId} not confirmed after ${maxRoundsToWait} rounds`);
 };
 /**
- * @deprecated Use `AlgoKitComposer` and the `maxFee` field in the transaction params instead.
+ * @deprecated Use `TransactionComposer` and the `maxFee` field in the transaction params instead.
  *
  * Limit the acceptable fee to a defined amount of µAlgo.
  * This also sets the transaction to be flatFee to ensure the transaction only succeeds at
@@ -689,21 +728,23 @@ const waitForConfirmation = async function (transactionId, maxRoundsToWait, algo
  */
 function capTransactionFee(transaction, maxAcceptableFee) {
     // If a flat fee hasn't already been defined
-    if (!transaction.flatFee) {
+    if (!('flatFee' in transaction) || !transaction.flatFee) {
         // Once a transaction has been constructed by algosdk, transaction.fee indicates what the total transaction fee
         // Will be based on the current suggested fee-per-byte value.
         if (transaction.fee > maxAcceptableFee.microAlgo) {
             throw new Error(`Cancelled transaction due to high network congestion fees. Algorand suggested fees would cause this transaction to cost ${transaction.fee} µALGO. Cap for this transaction is ${maxAcceptableFee.microAlgo} µALGO.`);
         }
-        else if (transaction.fee > algosdk.ALGORAND_MIN_TX_FEE) {
+        else if (transaction.fee > 1000000) {
             config.Config.logger.warn(`Algorand network congestion fees are in effect. This transaction will incur a fee of ${transaction.fee} µALGO.`);
         }
         // Now set the flat on the transaction. Otherwise the network may increase the fee above our cap and perform the transaction.
-        transaction.flatFee = true;
+        if ('flatFee' in transaction) {
+            transaction.flatFee = true;
+        }
     }
 }
 /**
- * @deprecated Use `AlgoKitComposer` and the `maxFee` and `staticFee` fields in the transaction params instead.
+ * @deprecated Use `TransactionComposer` and the `maxFee` and `staticFee` fields in the transaction params instead.
  *
  * Allows for control of fees on a `Transaction` or `SuggestedParams` object
  * @param transaction The transaction or suggested params
@@ -713,7 +754,9 @@ function controlFees(transaction, feeControl) {
     const { fee, maxFee } = feeControl;
     if (fee) {
         transaction.fee = Number(fee.microAlgo);
-        transaction.flatFee = true;
+        if ('flatFee' in transaction) {
+            transaction.flatFee = true;
+        }
     }
     if (maxFee !== undefined) {
         capTransactionFee(transaction, maxFee);
@@ -729,7 +772,18 @@ function controlFees(transaction, feeControl) {
  * @returns The suggested transaction parameters
  */
 async function getTransactionParams(params, algod) {
-    return params ? { ...params } : await algod.getTransactionParams().do();
+    if (params) {
+        return { ...params };
+    }
+    const p = await algod.getTransactionParams().do();
+    return {
+        fee: p.fee,
+        firstValid: p.firstValid,
+        lastValid: p.lastValid,
+        genesisID: p.genesisID,
+        genesisHash: p.genesisHash,
+        minFee: p.minFee,
+    };
 }
 /**
  * @deprecated Use `atc.clone().buildGroup()` instead.
@@ -754,12 +808,12 @@ exports.capTransactionFee = capTransactionFee;
 exports.controlFees = controlFees;
 exports.encodeLease = encodeLease;
 exports.encodeTransactionNote = encodeTransactionNote;
+exports.getABIReturnValue = getABIReturnValue;
 exports.getAtomicTransactionComposerTransactions = getAtomicTransactionComposerTransactions;
 exports.getSenderAddress = getSenderAddress;
 exports.getSenderTransactionSigner = getSenderTransactionSigner;
 exports.getTransactionParams = getTransactionParams;
 exports.getTransactionWithSigner = getTransactionWithSigner;
-exports.performAtomicTransactionComposerDryrun = performAtomicTransactionComposerDryrun;
 exports.populateAppCallResources = populateAppCallResources;
 exports.sendAtomicTransactionComposer = sendAtomicTransactionComposer;
 exports.sendGroupOfTransactions = sendGroupOfTransactions;