@algorandfoundation/algokit-utils 1.0.0-beta.9 → 1.1.0

package/app.js

@@ -23,15 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileTeal = exports.getAppByIndex = exports.getAppArgsForTransaction = exports.getABIReturn = exports.callApp = exports.updateApp = exports.createApp = exports.ABI_RETURN_PREFIX = exports.APP_PAGE_MAX_SIZE = void 0;
+exports.getABIMethodSignature = exports.compileTeal = exports.getAppByIndex = exports.getAppById = exports.getBoxReference = exports.getAppArgsForABICall = exports.getAppArgsForTransaction = exports.decodeAppState = exports.getAppBoxValuesFromABIType = exports.getAppBoxValueFromABIType = exports.getAppBoxValues = exports.getAppBoxValue = exports.getAppBoxNames = exports.getAppLocalState = exports.getAppGlobalState = exports.getABIReturn = exports.callApp = exports.updateApp = exports.createApp = void 0;
 const algosdk_1 = __importStar(require("algosdk"));
 const buffer_1 = require("buffer");
-const config_1 = require("./config");
+const _1 = require("./");
 const transaction_1 = require("./transaction");
-/** The maximum number of bytes in an app code page */
-exports.APP_PAGE_MAX_SIZE = 2048;
-/** First 4 bytes of SHA-512/256 hash of "return" */
-exports.ABI_RETURN_PREFIX = new Uint8Array([21, 31, 124, 117]);
+const app_1 = require("./types/app");
 /**
  * Creates a smart contract app, returns the details of the created app.
  * @param create The parameters to create the app with
@@ -40,38 +37,106 @@ exports.ABI_RETURN_PREFIX = new Uint8Array([21, 31, 124, 117]);
  */
 async function createApp(create, algod) {
     const { from, approvalProgram: approval, clearStateProgram: clear, schema, note, transactionParams, args, ...sendParams } = create;
-    const approvalProgram = typeof approval === 'string' ? (await compileTeal(approval, algod)).compiledBase64ToBytes : approval;
-    const clearProgram = typeof clear === 'string' ? (await compileTeal(clear, algod)).compiledBase64ToBytes : clear;
-    const transaction = algosdk_1.default.makeApplicationCreateTxnFromObject({
-        approvalProgram: approvalProgram,
-        clearProgram: clearProgram,
-        numLocalInts: schema.localInts,
-        numLocalByteSlices: schema.localByteSlices,
-        numGlobalInts: schema.globalInts,
-        numGlobalByteSlices: schema.globalByteSlices,
-        extraPages: schema.extraPages ?? Math.floor((approvalProgram.length + clearProgram.length) / exports.APP_PAGE_MAX_SIZE),
-        onComplete: algosdk_1.default.OnApplicationComplete.NoOpOC,
-        suggestedParams: await (0, transaction_1.getTransactionParams)(transactionParams, algod),
-        from: (0, transaction_1.getSenderAddress)(from),
-        note: (0, transaction_1.encodeTransactionNote)(note),
-        ...getAppArgsForTransaction(args),
-        rekeyTo: undefined,
-    });
-    const { confirmation } = await (0, transaction_1.sendTransaction)({ transaction, from, sendParams }, algod);
-    if (confirmation) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const appIndex = confirmation['application-index'];
-        config_1.AlgoKitConfig.getLogger(sendParams.suppressLog).debug(`Created app ${appIndex} from creator ${(0, transaction_1.getSenderAddress)(from)}`);
-        return {
-            transaction,
-            confirmation,
-            appIndex,
-            appAddress: algosdk_1.default.getApplicationAddress(appIndex),
-            return: getABIReturn(args, confirmation),
-        };
+    const compiledApproval = typeof approval === 'string' ? await compileTeal(approval, algod) : undefined;
+    const approvalProgram = compiledApproval ? compiledApproval.compiledBase64ToBytes : approval;
+    const compiledClear = typeof clear === 'string' ? await compileTeal(clear, algod) : undefined;
+    const clearProgram = compiledClear ? compiledClear.compiledBase64ToBytes : clear;
+    if (args && 'method' in args) {
+        const atc = attachATC(sendParams);
+        const before = (0, transaction_1.getAtomicTransactionComposerTransactions)(atc);
+        atc.addMethodCall({
+            appID: 0,
+            approvalProgram: approvalProgram,
+            clearProgram: clearProgram,
+            numLocalInts: schema.localInts,
+            numLocalByteSlices: schema.localByteSlices,
+            numGlobalInts: schema.globalInts,
+            numGlobalByteSlices: schema.globalByteSlices,
+            extraPages: schema.extraPages ?? Math.floor((approvalProgram.length + clearProgram.length) / app_1.APP_PAGE_MAX_SIZE),
+            onComplete: algosdk_1.default.OnApplicationComplete.NoOpOC,
+            suggestedParams: (0, transaction_1.controlFees)(await (0, transaction_1.getTransactionParams)(transactionParams, algod), sendParams),
+            note: (0, transaction_1.encodeTransactionNote)(note),
+            ...(await getAppArgsForABICall(args, from)),
+        });
+        if (sendParams.skipSending) {
+            const after = atc.clone().buildGroup();
+            return {
+                transaction: after[after.length - 1].txn,
+                transactions: after.slice(before.length).map((t) => t.txn),
+                appId: 0,
+                appAddress: '',
+                compiledApproval,
+                compiledClear,
+            };
+        }
+        const result = await (0, transaction_1.sendAtomicTransactionComposer)({ atc, sendParams }, algod);
+        const confirmation = result.confirmations ? result.confirmations[result.confirmations?.length - 1] : undefined;
+        if (confirmation) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const appId = confirmation['application-index'];
+            _1.Config.getLogger(sendParams.suppressLog).debug(`Created app ${appId} from creator ${(0, transaction_1.getSenderAddress)(from)}`);
+            return {
+                transactions: result.transactions,
+                confirmations: result.confirmations,
+                return: confirmation ? getABIReturn(args, confirmation) : undefined,
+                transaction: result.transactions[result.transactions.length - 1],
+                confirmation: confirmation,
+                appId,
+                appAddress: algosdk_1.default.getApplicationAddress(appId),
+                compiledApproval,
+                compiledClear,
+            };
+        }
+        else {
+            return {
+                transactions: result.transactions,
+                confirmations: result.confirmations,
+                return: confirmation ? getABIReturn(args, confirmation) : undefined,
+                transaction: result.transactions[result.transactions.length - 1],
+                confirmation: confirmation,
+                appId: 0,
+                appAddress: '',
+                compiledApproval,
+                compiledClear,
+            };
+        }
     }
     else {
-        return { transaction, appIndex: 0, appAddress: '' };
+        const transaction = algosdk_1.default.makeApplicationCreateTxnFromObject({
+            approvalProgram: approvalProgram,
+            clearProgram: clearProgram,
+            numLocalInts: schema.localInts,
+            numLocalByteSlices: schema.localByteSlices,
+            numGlobalInts: schema.globalInts,
+            numGlobalByteSlices: schema.globalByteSlices,
+            extraPages: schema.extraPages ?? Math.floor((approvalProgram.length + clearProgram.length) / app_1.APP_PAGE_MAX_SIZE),
+            onComplete: algosdk_1.default.OnApplicationComplete.NoOpOC,
+            suggestedParams: await (0, transaction_1.getTransactionParams)(transactionParams, algod),
+            from: (0, transaction_1.getSenderAddress)(from),
+            note: (0, transaction_1.encodeTransactionNote)(note),
+            ...getAppArgsForTransaction(args),
+            rekeyTo: undefined,
+        });
+        const { confirmation } = await (0, transaction_1.sendTransaction)({ transaction, from, sendParams }, algod);
+        if (confirmation) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const appId = confirmation['application-index'];
+            _1.Config.getLogger(sendParams.suppressLog).debug(`Created app ${appId} from creator ${(0, transaction_1.getSenderAddress)(from)}`);
+            return {
+                transaction,
+                transactions: [transaction],
+                confirmation,
+                confirmations: confirmation ? [confirmation] : undefined,
+                appId,
+                appAddress: algosdk_1.default.getApplicationAddress(appId),
+                return: getABIReturn(args, confirmation),
+                compiledApproval,
+                compiledClear,
+            };
+        }
+        else {
+            return { transaction, transactions: [transaction], appId: 0, appAddress: '', compiledApproval, compiledClear };
+        }
     }
 }
 exports.createApp = createApp;
@@ -82,27 +147,71 @@ exports.createApp = createApp;
  * @returns The transaction
  */
 async function updateApp(update, algod) {
-    const { appIndex, from, approvalProgram: approval, clearStateProgram: clear, note, transactionParams, args, ...sendParams } = update;
-    const approvalProgram = typeof approval === 'string' ? (await compileTeal(approval, algod)).compiledBase64ToBytes : approval;
-    const clearProgram = typeof clear === 'string' ? (await compileTeal(clear, algod)).compiledBase64ToBytes : clear;
-    const transaction = algosdk_1.default.makeApplicationUpdateTxnFromObject({
-        appIndex,
-        approvalProgram: approvalProgram,
-        clearProgram: clearProgram,
-        suggestedParams: await (0, transaction_1.getTransactionParams)(transactionParams, algod),
-        from: (0, transaction_1.getSenderAddress)(from),
-        note: (0, transaction_1.encodeTransactionNote)(note),
-        ...getAppArgsForTransaction(args),
-        rekeyTo: undefined,
-    });
-    config_1.AlgoKitConfig.getLogger(sendParams.suppressLog).debug(`Updating app ${appIndex}`);
-    const result = await (0, transaction_1.sendTransaction)({ transaction, from, sendParams }, algod);
-    return {
-        ...result,
-        return: getABIReturn(args, result.confirmation),
-    };
+    const { appId, from, approvalProgram: approval, clearStateProgram: clear, note, transactionParams, args, ...sendParams } = update;
+    const compiledApproval = typeof approval === 'string' ? await compileTeal(approval, algod) : undefined;
+    const approvalProgram = compiledApproval ? compiledApproval.compiledBase64ToBytes : approval;
+    const compiledClear = typeof clear === 'string' ? await compileTeal(clear, algod) : undefined;
+    const clearProgram = compiledClear ? compiledClear.compiledBase64ToBytes : clear;
+    _1.Config.getLogger(sendParams.suppressLog).debug(`Updating app ${appId}`);
+    if (args && 'method' in args) {
+        const atc = attachATC(sendParams);
+        const before = (0, transaction_1.getAtomicTransactionComposerTransactions)(atc);
+        atc.addMethodCall({
+            appID: appId,
+            onComplete: algosdk_1.OnApplicationComplete.UpdateApplicationOC,
+            approvalProgram: approvalProgram,
+            clearProgram: clearProgram,
+            suggestedParams: (0, transaction_1.controlFees)(await (0, transaction_1.getTransactionParams)(transactionParams, algod), sendParams),
+            note: (0, transaction_1.encodeTransactionNote)(note),
+            ...(await getAppArgsForABICall(args, from)),
+        });
+        if (sendParams.skipSending) {
+            const after = atc.clone().buildGroup();
+            return {
+                transaction: after[after.length - 1].txn,
+                transactions: after.slice(before.length).map((t) => t.txn),
+            };
+        }
+        const result = await (0, transaction_1.sendAtomicTransactionComposer)({ atc, sendParams }, algod);
+        const confirmation = result.confirmations ? result.confirmations[result.confirmations?.length - 1] : undefined;
+        return {
+            transactions: result.transactions,
+            confirmations: result.confirmations,
+            return: confirmation ? getABIReturn(args, confirmation) : undefined,
+            transaction: result.transactions[result.transactions.length - 1],
+            confirmation: confirmation,
+        };
+    }
+    else {
+        const transaction = algosdk_1.default.makeApplicationUpdateTxnFromObject({
+            appIndex: appId,
+            approvalProgram: approvalProgram,
+            clearProgram: clearProgram,
+            suggestedParams: await (0, transaction_1.getTransactionParams)(transactionParams, algod),
+            from: (0, transaction_1.getSenderAddress)(from),
+            note: (0, transaction_1.encodeTransactionNote)(note),
+            ...getAppArgsForTransaction(args),
+            rekeyTo: undefined,
+        });
+        const result = await (0, transaction_1.sendTransaction)({ transaction, from, sendParams }, algod);
+        return {
+            ...result,
+            transactions: [result.transaction],
+            confirmations: result.confirmation ? [result.confirmation] : undefined,
+            return: getABIReturn(args, result.confirmation),
+            compiledApproval,
+            compiledClear,
+        };
+    }
 }
 exports.updateApp = updateApp;
+function attachATC(sendParams) {
+    if (sendParams.atc) {
+        sendParams.skipSending = true;
+    }
+    sendParams.atc = sendParams.atc ?? new algosdk_1.AtomicTransactionComposer();
+    return sendParams.atc;
+}
 /**
  * Issues a call to a given app.
  * @param call The call details.
@@ -110,9 +219,44 @@ exports.updateApp = updateApp;
  * @returns The result of the call
  */
 async function callApp(call, algod) {
-    const { appIndex, callType, from, args, note, transactionParams, ...sendParams } = call;
-    const appCallParameters = {
-        appIndex: appIndex,
+    const { appId, callType, from, args, note, transactionParams, ...sendParams } = call;
+    if (args && 'method' in args) {
+        const atc = attachATC(sendParams);
+        const before = (0, transaction_1.getAtomicTransactionComposerTransactions)(atc);
+        atc.addMethodCall({
+            appID: appId,
+            suggestedParams: (0, transaction_1.controlFees)(await (0, transaction_1.getTransactionParams)(transactionParams, algod), sendParams),
+            note: (0, transaction_1.encodeTransactionNote)(note),
+            onComplete: callType === 'normal'
+                ? algosdk_1.OnApplicationComplete.NoOpOC
+                : callType === 'clearstate'
+                    ? algosdk_1.OnApplicationComplete.ClearStateOC
+                    : callType === 'closeout'
+                        ? algosdk_1.OnApplicationComplete.CloseOutOC
+                        : callType === 'delete'
+                            ? algosdk_1.OnApplicationComplete.DeleteApplicationOC
+                            : algosdk_1.OnApplicationComplete.OptInOC,
+            ...(await getAppArgsForABICall(args, from)),
+        });
+        if (sendParams.skipSending) {
+            const after = atc.clone().buildGroup();
+            return {
+                transaction: after[after.length - 1].txn,
+                transactions: after.slice(before.length).map((t) => t.txn),
+            };
+        }
+        const result = await (0, transaction_1.sendAtomicTransactionComposer)({ atc, sendParams }, algod);
+        const confirmation = result.confirmations ? result.confirmations[result.confirmations?.length - 1] : undefined;
+        return {
+            transactions: result.transactions,
+            confirmations: result.confirmations,
+            return: confirmation ? getABIReturn(args, confirmation) : undefined,
+            transaction: result.transactions[result.transactions.length - 1],
+            confirmation: confirmation,
+        };
+    }
+    const appCallParams = {
+        appIndex: appId,
         from: (0, transaction_1.getSenderAddress)(from),
         suggestedParams: await (0, transaction_1.getTransactionParams)(transactionParams, algod),
         ...getAppArgsForTransaction(args),
@@ -122,144 +266,317 @@ async function callApp(call, algod) {
     let transaction;
     switch (callType) {
         case 'optin':
-            transaction = algosdk_1.default.makeApplicationOptInTxnFromObject(appCallParameters);
+            transaction = algosdk_1.default.makeApplicationOptInTxnFromObject(appCallParams);
             break;
         case 'clearstate':
-            transaction = algosdk_1.default.makeApplicationClearStateTxnFromObject(appCallParameters);
+            transaction = algosdk_1.default.makeApplicationClearStateTxnFromObject(appCallParams);
             break;
         case 'closeout':
-            transaction = algosdk_1.default.makeApplicationCloseOutTxnFromObject(appCallParameters);
+            transaction = algosdk_1.default.makeApplicationCloseOutTxnFromObject(appCallParams);
             break;
         case 'delete':
-            transaction = algosdk_1.default.makeApplicationDeleteTxnFromObject(appCallParameters);
+            transaction = algosdk_1.default.makeApplicationDeleteTxnFromObject(appCallParams);
             break;
         case 'normal':
-            transaction = algosdk_1.default.makeApplicationNoOpTxnFromObject(appCallParameters);
+            transaction = algosdk_1.default.makeApplicationNoOpTxnFromObject(appCallParams);
             break;
     }
     const result = await (0, transaction_1.sendTransaction)({ transaction, from, sendParams }, algod);
     return {
         ...result,
+        transactions: [result.transaction],
+        confirmations: result.confirmation ? [result.confirmation] : undefined,
         return: getABIReturn(args, result.confirmation),
     };
 }
 exports.callApp = callApp;
+/**
+ * Returns any ABI return values for the given app call arguments and transaction confirmation.
+ * @param args The arguments that were used for the call
+ * @param confirmation The transaction confirmation from algod
+ * @returns The return value for the method call
+ */
 function getABIReturn(args, confirmation) {
-    try {
-        if (!args || !('method' in args)) {
-            return undefined;
-        }
-        const method = 'txnCount' in args.method ? args.method : new algosdk_1.ABIMethod(args.method);
-        if (method.returns.type !== 'void' && confirmation) {
-            const logs = confirmation.logs || [];
-            if (logs.length === 0) {
-                throw new Error('App call transaction did not log a return value');
-            }
-            const lastLog = logs[logs.length - 1];
-            if (lastLog.byteLength < 4 || lastLog.slice(0, 4).toString() !== exports.ABI_RETURN_PREFIX.toString()) {
-                throw new Error('App call transaction did not log a return value (ABI_RETURN_PREFIX not found)');
-            }
-            return {
-                rawReturnValue: new Uint8Array(lastLog.slice(4)),
-                returnValue: method.returns.type.decode(new Uint8Array(lastLog.slice(4))),
+    if (!args || !('method' in args)) {
+        return undefined;
+    }
+    const method = 'txnCount' in args.method ? args.method : new algosdk_1.ABIMethod(args.method);
+    if (method.returns.type !== 'void' && confirmation) {
+        // The parseMethodResponse method mutates the second parameter :(
+        const resultDummy = {
+            txID: '',
+            method,
+            rawReturnValue: new Uint8Array(),
+        };
+        const response = algosdk_1.AtomicTransactionComposer.parseMethodResponse(method, resultDummy, confirmation);
+        return !response.decodeError
+            ? {
+                rawReturnValue: response.rawReturnValue,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                returnValue: response.returnValue,
                 decodeError: undefined,
+            }
+            : {
+                rawReturnValue: undefined,
+                returnValue: undefined,
+                decodeError: response.decodeError,
             };
-        }
     }
-    catch (e) {
+    return undefined;
+}
+exports.getABIReturn = getABIReturn;
+/**
+ * Returns the current global state values for the given app ID
+ * @param appId The ID of the app return global state for
+ * @param algod An algod client instance
+ * @returns The current global state
+ */
+async function getAppGlobalState(appId, algod) {
+    const appInfo = await getAppById(appId, algod);
+    if (!appInfo.params || !appInfo.params['global-state']) {
+        throw new Error("Couldn't find global state");
+    }
+    return decodeAppState(appInfo.params['global-state']);
+}
+exports.getAppGlobalState = getAppGlobalState;
+/**
+ * Returns the current global state values for the given app ID and account
+ * @param appId The ID of the app return global state for
+ * @param account Either the string address of an account or an account object for the account to get local state for the given app
+ * @param algod An algod client instance
+ * @returns The current local state for the given (app, account) combination
+ */
+async function getAppLocalState(appId, account, algod) {
+    const accountAddress = typeof account === 'string' ? account : (0, transaction_1.getSenderAddress)(account);
+    const appInfo = await algod.accountApplicationInformation(accountAddress, appId).do();
+    if (!appInfo['app-local-state'] || !appInfo['app-local-state']['key-value']) {
+        throw new Error("Couldn't find local state");
+    }
+    return decodeAppState(appInfo['app-local-state']['key-value']);
+}
+exports.getAppLocalState = getAppLocalState;
+/**
+ * Returns the names of the boxes for the given app.
+ * @param appId The ID of the app return box names for
+ * @param algod An algod client instance
+ * @returns The current box names
+ */
+async function getAppBoxNames(appId, algod) {
+    const boxResult = await algod.getApplicationBoxes(appId).do();
+    return boxResult.boxes.map((b) => {
         return {
-            rawReturnValue: undefined,
-            returnValue: undefined,
-            decodeError: e,
+            nameRaw: b.name,
+            nameBase64: buffer_1.Buffer.from(b.name).toString('base64'),
+            name: buffer_1.Buffer.from(b.name).toString('utf-8'),
         };
+    });
+}
+exports.getAppBoxNames = getAppBoxNames;
+/**
+ * Returns the value of the given box name for the given app.
+ * @param appId The ID of the app return box names for
+ * @param boxName The name of the box to return either as a string, binary array or `BoxName`
+ * @param algod An algod client instance
+ * @returns The current box value as a byte array
+ */
+async function getAppBoxValue(appId, boxName, algod) {
+    const name = typeof boxName === 'string' ? new Uint8Array(buffer_1.Buffer.from(boxName, 'utf-8')) : 'name' in boxName ? boxName.nameRaw : boxName;
+    const boxResult = await algod.getApplicationBoxByName(appId, name).do();
+    return boxResult.value;
+}
+exports.getAppBoxValue = getAppBoxValue;
+/**
+ * Returns the value of the given box names for the given app.
+ * @param appId The ID of the app return box names for
+ * @param boxNames The names of the boxes to return either as a string, binary array or `BoxName`
+ * @param algod An algod client instance
+ * @returns The current box values as a byte array in the same order as the passed in box names
+ */
+async function getAppBoxValues(appId, boxNames, algod) {
+    return await Promise.all(boxNames.map(async (boxName) => await getAppBoxValue(appId, boxName, algod)));
+}
+exports.getAppBoxValues = getAppBoxValues;
+/**
+ * Returns the value of the given box name for the given app decoded based on the given ABI type.
+ * @param request The parameters for the box value request
+ * @param algod An algod client instance
+ * @returns The current box value as an ABI value
+ */
+async function getAppBoxValueFromABIType(request, algod) {
+    const { appId, boxName, type } = request;
+    const value = await getAppBoxValue(appId, boxName, algod);
+    return type.decode(value);
+}
+exports.getAppBoxValueFromABIType = getAppBoxValueFromABIType;
+/**
+ * Returns the value of the given box names for the given app decoded based on the given ABI type.
+ * @param request The parameters for the box value request
+ * @param algod An algod client instance
+ * @returns The current box values as an ABI value in the same order as the passed in box names
+ */
+async function getAppBoxValuesFromABIType(request, algod) {
+    const { appId, boxNames, type } = request;
+    return await Promise.all(boxNames.map(async (boxName) => await getAppBoxValueFromABIType({ appId, boxName, type }, algod)));
+}
+exports.getAppBoxValuesFromABIType = getAppBoxValuesFromABIType;
+/**
+ * Converts an array of global/local state values from the algod api to a more friendly
+ * generic object keyed by the UTF-8 value of the key.
+ * @param state A `global-state`, `local-state`, `global-state-deltas` or `local-state-deltas`
+ * @returns An object keyeed by the UTF-8 representation of the key with various parsings of the values
+ */
+function decodeAppState(state) {
+    const stateValues = {};
+    // Start with empty set
+    for (const stateVal of state) {
+        const keyBase64 = stateVal.key;
+        const keyRaw = buffer_1.Buffer.from(keyBase64, 'base64');
+        const key = keyRaw.toString('utf-8');
+        const tealValue = stateVal.value;
+        const dataTypeFlag = 'action' in tealValue ? tealValue.action : tealValue.type;
+        let valueBase64;
+        let valueRaw;
+        switch (dataTypeFlag) {
+            case 1:
+                valueBase64 = 'bytes' in tealValue ? tealValue.bytes : '';
+                valueRaw = buffer_1.Buffer.from(valueBase64, 'base64');
+                stateValues[key] = {
+                    keyRaw,
+                    keyBase64,
+                    valueRaw: new Uint8Array(valueRaw),
+                    valueBase64: valueBase64,
+                    value: valueRaw.toString('utf-8'),
+                };
+                break;
+            case 2:
+                // eslint-disable-next-line no-case-declarations
+                const value = 'uint' in tealValue ? tealValue.uint : 0;
+                stateValues[key] = {
+                    keyRaw,
+                    keyBase64,
+                    value,
+                };
+                break;
+            default:
+                throw new Error(`Received unknown state data type of ${dataTypeFlag}`);
+        }
     }
-    return undefined;
+    return stateValues;
 }
-exports.getABIReturn = getABIReturn;
-/** Returns the app args ready to load onto an app @see {Transaction} object */
+exports.decodeAppState = decodeAppState;
+/**
+ * Returns the app args ready to load onto an app `Transaction` object
+ * @param args The app call args
+ * @returns The args ready to load into a `Transaction`
+ */
 function getAppArgsForTransaction(args) {
     if (!args)
         return undefined;
-    let actualArgs;
-    if ('method' in args) {
-        // todo: Land a change to algosdk that extract the logic from ATC, because (fair warning) this is a HACK
-        // I don't want to have to rewrite all of the ABI resolution logic so using an ATC temporarily here
-        // and passing stuff in to keep it happy like a randomly generated account :O
-        // Most of these values aren't being used since the transaction is discarded
-        const dummyAtc = new algosdk_1.AtomicTransactionComposer();
-        const dummyAccount = algosdk_1.default.generateAccount();
-        const dummyAppId = 1;
-        const dummyParams = {
-            fee: 1,
-            firstRound: 1,
-            genesisHash: buffer_1.Buffer.from('abcd', 'utf-8').toString('base64'),
-            genesisID: 'a',
-            lastRound: 1,
-        };
-        const dummyOnComplete = algosdk_1.OnApplicationComplete.NoOpOC;
-        dummyAtc.addMethodCall({
-            method: 'txnCount' in args.method ? args.method : new algosdk_1.ABIMethod(args.method),
-            methodArgs: args.args,
-            // Rest are dummy values
-            appID: dummyAppId,
-            sender: dummyAccount.addr,
-            signer: (0, algosdk_1.makeBasicAccountTransactionSigner)(dummyAccount),
-            suggestedParams: dummyParams,
-            onComplete: dummyOnComplete,
-        });
-        const txn = dummyAtc.buildGroup()[0];
-        actualArgs = {
-            accounts: txn.txn.appAccounts,
-            appArgs: txn.txn.appArgs,
-            apps: txn.txn.appForeignApps,
-            assets: txn.txn.appForeignAssets,
-            boxes: txn.txn.boxes,
-            lease: args.lease,
-        };
-    }
-    else {
-        actualArgs = args;
-    }
     const encoder = new TextEncoder();
     return {
-        accounts: actualArgs?.accounts?.map((a) => (typeof a === 'string' ? a : algosdk_1.default.encodeAddress(a.publicKey))),
-        appArgs: actualArgs?.appArgs?.map((a) => (typeof a === 'string' ? encoder.encode(a) : a)),
-        boxes: actualArgs?.boxes?.map((ref) => ({
-            appIndex: ref.appIndex,
-            name: typeof ref.name === 'string' ? encoder.encode(ref.name) : ref.name,
-        })),
-        foreignApps: actualArgs?.apps,
-        foreignAssets: actualArgs?.assets,
-        lease: typeof actualArgs?.lease === 'string' ? encoder.encode(actualArgs?.lease) : actualArgs?.lease,
+        accounts: args?.accounts?.map((a) => (typeof a === 'string' ? a : algosdk_1.default.encodeAddress(a.publicKey))),
+        appArgs: args?.appArgs?.map((a) => (typeof a === 'string' ? encoder.encode(a) : a)),
+        boxes: args.boxes?.map(getBoxReference),
+        foreignApps: args?.apps,
+        foreignAssets: args?.assets,
+        lease: typeof args?.lease === 'string' ? encoder.encode(args?.lease) : args?.lease,
     };
 }
 exports.getAppArgsForTransaction = getAppArgsForTransaction;
+/**
+ * Returns the app args ready to load onto an ABI method call in `AtomicTransactionComposer`
+ * @param args The ABI app call args
+ * @param from The transaction signer
+ * @returns The parameters ready to pass into `addMethodCall` within AtomicTransactionComposer
+ */
+async function getAppArgsForABICall(args, from) {
+    const encoder = new TextEncoder();
+    const signer = (0, transaction_1.getSenderTransactionSigner)(from);
+    const methodArgs = await Promise.all(args.args?.map(async (a) => {
+        if (typeof a !== 'object') {
+            return a;
+        }
+        // Handle the various forms of transactions to wrangle them for ATC
+        return 'txn' in a
+            ? a
+            : 'then' in a
+                ? { txn: (await a).transaction, signer }
+                : 'transaction' in a
+                    ? { txn: a.transaction, signer }
+                    : 'txID' in a
+                        ? { txn: a, signer }
+                        : a;
+    }));
+    return {
+        method: 'txnCount' in args.method ? args.method : new algosdk_1.ABIMethod(args.method),
+        sender: (0, transaction_1.getSenderAddress)(from),
+        signer: signer,
+        boxes: args.boxes?.map(getBoxReference),
+        lease: typeof args.lease === 'string' ? encoder.encode(args.lease) : args.lease,
+        methodArgs: methodArgs,
+        rekeyTo: undefined,
+    };
+}
+exports.getAppArgsForABICall = getAppArgsForABICall;
+/**
+ * Returns a `algosdk.BoxReference` given a `BoxIdentifier` or `BoxReference`.
+ * @param box The box to return a reference for
+ * @returns The box reference ready to pass into a `Transaction`
+ */
+function getBoxReference(box) {
+    const encoder = new TextEncoder();
+    if (typeof box === 'object' && 'appIndex' in box) {
+        return box;
+    }
+    const ref = typeof box === 'object' && 'appId' in box ? box : { appId: 0, name: box };
+    return {
+        appIndex: ref.appId,
+        name: typeof ref.name === 'string'
+            ? encoder.encode(ref.name)
+            : 'length' in ref.name
+                ? ref.name
+                : algosdk_1.default.decodeAddress((0, transaction_1.getSenderAddress)(ref.name)).publicKey,
+    };
+}
+exports.getBoxReference = getBoxReference;
 /**
  * Gets the current data for the given app from algod.
  *
- * @param appIndex The index of the app
+ * @param appId The id of the app
  * @param algod An algod client
  * @returns The data about the app
  */
-async function getAppByIndex(appIndex, algod) {
-    return (await algod.getApplicationByID(appIndex).do());
+async function getAppById(appId, algod) {
+    return (await algod.getApplicationByID(appId).do());
 }
-exports.getAppByIndex = getAppByIndex;
+exports.getAppById = getAppById;
+/** @deprecated Use `algokit.getAppById` instead. */
+exports.getAppByIndex = getAppById;
 /**
- * Compiles the given TEAL using algod and returns the result.
+ * Compiles the given TEAL using algod and returns the result, including source map.
  *
  * @param algod An algod client
  * @param tealCode The TEAL code
  * @returns The information about the compiled file
  */
 async function compileTeal(tealCode, algod) {
-    const compiled = await algod.compile(tealCode).do();
+    const compiled = await algod.compile(tealCode).sourcemap(true).do();
     return {
         teal: tealCode,
         compiled: compiled.result,
         compiledHash: compiled.hash,
         compiledBase64ToBytes: new Uint8Array(buffer_1.Buffer.from(compiled.result, 'base64')),
+        sourceMap: new algosdk_1.SourceMap(compiled['sourcemap']),
     };
 }
 exports.compileTeal = compileTeal;
+/**
+ * Returns the encoded ABI spec for a given ABI Method
+ * @param method The method to return a signature for
+ * @returns The encoded ABI method spec e.g. `method_name(uint64,string)string`
+ */
+const getABIMethodSignature = (method) => {
+    return 'getSignature' in method ? method.getSignature() : new algosdk_1.ABIMethod(method).getSignature();
+};
+exports.getABIMethodSignature = getABIMethodSignature;
 //# sourceMappingURL=app.js.map