@algorandfoundation/algokit-utils 6.3.0-beta.1 → 7.0.0-alpha.1

package/{transaction → src/transaction}/transaction.js

@@ -3,16 +3,18 @@
 var algosdk = require('algosdk');
 var buffer = require('buffer');
 var config = require('../config.js');
-var simulateAndPersistResponse = require('../debugging/simulate-and-persist-response.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;
-/** Encodes a transaction note into a byte array ready to be included in an Algorand transaction.
+/**
+ * @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.
  *
  * @param note The transaction note
  * @returns the transaction note ready for inclusion in a transaction
@@ -78,14 +80,20 @@ function encodeLease(lease) {
     }
 }
 /**
+ * @deprecated Use `algorand.client` to interact with accounts, and use `.addr` to get the address
+ * and/or move from using `SendTransactionFrom` to `TransactionSignerAccount` and use `.addr` instead.
+ *
  * Returns the public address of the given transaction sender.
  * @param sender A transaction sender
  * @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` / `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
  * AtomicTransactionComposer's addTransaction method.
  * @param transaction One of: A TransactionWithSigner object (returned as is), a TransactionToSign object (signer is obtained from the
@@ -124,6 +132,9 @@ const memoize = (fn) => {
     return cached;
 };
 /**
+ * @deprecated Use `TransactionSignerAccount` instead of `SendTransactionFrom` or use
+ * `algosdk.makeBasicAccountTransactionSigner` / `algosdk.makeLogicSigAccountTransactionSigner`.
+ *
  * Returns a `TransactionSigner` for the given transaction sender.
  * This function has memoization, so will return the same transaction signer for a given sender.
  * @param sender A transaction sender
@@ -137,6 +148,10 @@ const getSenderTransactionSigner = memoize(function (sender) {
             : algosdk.makeBasicAccountTransactionSigner(sender);
 });
 /**
+ * @deprecated Use `AlgorandClient` / `TransactionComposer` to sign transactions
+ * or use the relevant underlying `account.signTxn` / `algosdk.signLogicSigTransactionObject`
+ * / `multiSigAccount.sign` / `TransactionSigner` methods directly.
+ *
  * Signs a single transaction by the given signer.
  * @param transaction The transaction to sign
  * @param signer The signer to sign
@@ -151,7 +166,10 @@ const signTransaction = async (transaction, signer) => {
                 ? signer.sign(transaction)
                 : (await signer.signer([transaction], [0]))[0];
 };
-/** Prepares a transaction for sending and then (if instructed) signs and sends the given transaction to the chain.
+/**
+ * @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.
  *
  * @param send The details for the transaction to prepare/send, including:
  *   * `transaction`: The unsigned transaction
@@ -199,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}`);
@@ -254,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');
@@ -262,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}`);
         }
@@ -286,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
@@ -300,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;
             }
@@ -324,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;
             }
         }
@@ -348,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;
             }
         }
@@ -359,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;
@@ -379,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;
@@ -454,98 +495,87 @@ async function populateAppCallResources(atc, algod) {
 }
 /**
  * Signs and sends transactions that have been collected by an `AtomicTransactionComposer`.
- * @param atcSend The parameters controlling the send, including:
- *  * `atc` The `AtomicTransactionComposer`
- *  * `sendParams` The parameters to control the send behaviour
+ * @param atcSend The parameters controlling the send, including `atc` The `AtomicTransactionComposer` and params to control send behaviour
  * @param algod An algod client
  * @returns An object with transaction IDs, transactions, group transaction ID (`groupTransactionId`) if more than 1 transaction sent, and (if `skipWaiting` is `false` or unset) confirmation (`confirmation`)
  */
 const sendAtomicTransactionComposer = async function (atcSend, algod) {
-    const { atc: givenAtc, sendParams } = atcSend;
+    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 = sendParams?.populateAppCallResources ?? config.Config.populateAppCallResources;
-        if (populateResources) {
+        const populateResources = executeParams?.populateAppCallResources ?? sendParams?.populateAppCallResources ?? config.Config.populateAppCallResources;
+        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;
         });
         let groupId = undefined;
         if (transactionsToSend.length > 1) {
             groupId = transactionsToSend[0].group ? buffer.Buffer.from(transactionsToSend[0].group).toString('base64') : '';
-            config.Config.getLogger(sendParams?.suppressLog).verbose(`Sending group of ${transactionsToSend.length} transactions (${groupId})`, {
+            config.Config.getLogger(executeParams?.suppressLog ?? sendParams?.suppressLog).verbose(`Sending group of ${transactionsToSend.length} transactions (${groupId})`, {
                 transactionsToSend,
             });
-            config.Config.getLogger(sendParams?.suppressLog).debug(`Transaction IDs (${groupId})`, transactionsToSend.map((t) => t.txID()));
+            config.Config.getLogger(executeParams?.suppressLog ?? sendParams?.suppressLog).debug(`Transaction IDs (${groupId})`, transactionsToSend.map((t) => t.txID()));
         }
-        if (config.Config.debug && config.Config.projectRoot && config.Config.traceAll) {
+        if (config.Config.debug && config.Config.traceAll) {
             // Dump the traces to a file for use with AlgoKit AVM debugger
-            await simulateAndPersistResponse.simulateAndPersistResponse({
-                atc,
-                projectRoot: config.Config.projectRoot,
-                algod,
-                bufferSizeMb: config.Config.traceBufferSizeMb,
+            const simulateResponse = await performAtomicTransactionComposerSimulate.performAtomicTransactionComposerSimulate(atc, algod);
+            await config.Config.events.emitAsync(types_lifecycleEvents.EventType.TxnGroupSimulated, {
+                simulateResponse,
             });
         }
-        const result = await atc.execute(algod, sendParams?.maxRoundsToWaitForConfirmation ?? 5);
+        const result = await atc.execute(algod, executeParams?.maxRoundsToWaitForConfirmation ?? sendParams?.maxRoundsToWaitForConfirmation ?? 5);
         if (transactionsToSend.length > 1) {
-            config.Config.getLogger(sendParams?.suppressLog).verbose(`Group transaction (${groupId}) sent with ${transactionsToSend.length} transactions`);
+            config.Config.getLogger(executeParams?.suppressLog ?? sendParams?.suppressLog).verbose(`Group transaction (${groupId}) sent with ${transactionsToSend.length} transactions`);
         }
         else {
-            config.Config.getLogger(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
     }
     catch (e) {
-        // Remove headers as it doesn't have anything useful.
-        delete e.response?.headers;
+        // Create a new error object so the stack trace is correct (algosdk throws an error with a more limited stack trace)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const err = new Error(typeof e === 'object' ? e?.message : 'Received error executing Atomic Transaction Composer');
+        err.cause = e;
+        if (typeof e === 'object') {
+            // 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') {
-            e.traces = [];
-            config.Config.logger.error('Received error executing Atomic Transaction Composer and debug flag enabled; attempting simulation to get more information', e);
-            let simulate = undefined;
-            if (config.Config.debug && config.Config.projectRoot && !config.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
-                simulate = await simulateAndPersistResponse.simulateAndPersistResponse({
-                    atc,
-                    projectRoot: config.Config.projectRoot,
-                    algod,
-                    bufferSizeMb: config.Config.traceBufferSizeMb,
+            err.traces = [];
+            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) {
+                // 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,
                 });
             }
-            else {
-                simulate = await performAtomicTransactionComposerSimulate.performAtomicTransactionComposerSimulate(atc, algod);
-            }
             if (simulate && simulate.txnGroups[0].failedAt) {
                 for (const txn of simulate.txnGroups[0].txnResults) {
-                    e.traces.push({
-                        trace: txn.execTrace?.get_obj_for_encoding(),
+                    err.traces.push({
+                        trace: txn.execTrace?.toEncodingData(),
                         appBudget: txn.appBudgetConsumed,
                         logicSigBudget: txn.logicSigBudgetConsumed,
                         logs: txn.txnResult.logs,
@@ -555,26 +585,53 @@ const sendAtomicTransactionComposer = async function (atcSend, algod) {
             }
         }
         else {
-            config.Config.logger.error('Received error executing Atomic Transaction Composer, for more information enable the debug flag', e);
+            config.Config.logger.error('Received error executing Atomic Transaction Composer, for more information enable the debug flag', err);
         }
-        throw e;
+        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;
     }
 };
 /**
- * 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 `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
  *
  * @param groupSend The group details to send, with:
@@ -624,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');
     }
@@ -633,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) {
@@ -661,6 +718,8 @@ const waitForConfirmation = async function (transactionId, maxRoundsToWait, algo
     throw new Error(`Transaction ${transactionId} not confirmed after ${maxRoundsToWait} rounds`);
 };
 /**
+ * @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
  * the estimated rate.
@@ -669,20 +728,24 @@ 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 `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
  * @param feeControl The fee control parameters
@@ -690,8 +753,10 @@ function capTransactionFee(transaction, maxAcceptableFee) {
 function controlFees(transaction, feeControl) {
     const { fee, maxFee } = feeControl;
     if (fee) {
-        transaction.fee = fee.microAlgo;
-        transaction.flatFee = true;
+        transaction.fee = Number(fee.microAlgo);
+        if ('flatFee' in transaction) {
+            transaction.flatFee = true;
+        }
     }
     if (maxFee !== undefined) {
         capTransactionFee(transaction, maxFee);
@@ -699,15 +764,30 @@ function controlFees(transaction, feeControl) {
     return transaction;
 }
 /**
+ * @deprecated Use `suggestedParams ? { ...suggestedParams } : await algod.getTransactionParams().do()` instead
+ *
  * Returns suggested transaction parameters from algod unless some are already provided.
  * @param params Optionally provide parameters to use
  * @param algod Algod algod
  * @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.
+ *
  * Returns the array of transactions currently present in the given `AtomicTransactionComposer`
  * @param atc The atomic transaction composer
  * @returns The array of transactions with signers
@@ -728,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;