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

package/app.js

@@ -1,199 +1,82 @@
 'use strict';
 
 var algosdk = require('algosdk');
-var buffer = require('buffer');
-var config = require('./config.js');
+var legacyBridge = require('./transaction/legacy-bridge.js');
 var transaction = require('./transaction/transaction.js');
-var types_app = require('./types/app.js');
+var types_appManager = require('./types/app-manager.js');
 var util = require('./util.js');
 
 var ABIMethod = algosdk.ABIMethod;
-var AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
-var modelsv2 = algosdk.modelsv2;
 var OnApplicationComplete = algosdk.OnApplicationComplete;
-var SourceMap = algosdk.SourceMap;
 /**
+ * @deprecated Use `algorand.send.appCreate()` / `algorand.createTransaction.appCreate()` / `algorand.send.appCreateMethodCall()`
+ * / `algorand.createTransaction.appCreateMethodCall()` instead
+ *
  * Creates a smart contract app, returns the details of the created app.
  * @param create The parameters to create the app with
  * @param algod An algod client
  * @returns The details of the created app, or the transaction to create it if `skipSending` and the compilation result
  */
 async function createApp(create, algod) {
-    const { from, approvalProgram: approval, clearStateProgram: clear, schema, note, transactionParams, args, onCompleteAction, ...sendParams } = create;
-    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 && args.method) {
-        const atc = attachATC(sendParams);
-        const before = transaction.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) / types_app.APP_PAGE_MAX_SIZE),
-            onComplete: getAppOnCompleteAction(onCompleteAction),
-            suggestedParams: transaction.controlFees(await transaction.getTransactionParams(transactionParams, algod), sendParams),
-            note: transaction.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 transaction.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.applicationIndex;
-            config.Config.getLogger(sendParams.suppressLog).debug(`Created app ${appId} from creator ${transaction.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.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 {
-        const transaction$1 = algosdk.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) / types_app.APP_PAGE_MAX_SIZE),
-            onComplete: getAppOnCompleteAction(onCompleteAction),
-            suggestedParams: await transaction.getTransactionParams(transactionParams, algod),
-            from: transaction.getSenderAddress(from),
-            note: transaction.encodeTransactionNote(note),
-            ...getAppArgsForTransaction(args),
-            rekeyTo: args?.rekeyTo ? (typeof args.rekeyTo === 'string' ? args.rekeyTo : transaction.getSenderAddress(args.rekeyTo)) : undefined,
-        });
-        const { confirmation } = await transaction.sendTransaction({ transaction: transaction$1, from, sendParams }, algod);
-        if (confirmation) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const appId = confirmation.applicationIndex;
-            config.Config.getLogger(sendParams.suppressLog).debug(`Created app ${appId} from creator ${transaction.getSenderAddress(from)}`);
-            return {
-                transaction: transaction$1,
-                transactions: [transaction$1],
-                confirmation,
-                confirmations: confirmation ? [confirmation] : undefined,
-                appId,
-                appAddress: algosdk.getApplicationAddress(appId),
-                return: getABIReturn(args, confirmation),
-                compiledApproval,
-                compiledClear,
-            };
-        }
-        else {
-            return { transaction: transaction$1, transactions: [transaction$1], appId: 0, appAddress: '', compiledApproval, compiledClear };
-        }
+    const onComplete = getAppOnCompleteAction(create.onCompleteAction);
+    if (onComplete === algosdk.OnApplicationComplete.ClearStateOC) {
+        throw new Error('Cannot create an app with on-complete action of ClearState');
     }
+    const result = create.args?.method
+        ? await legacyBridge.legacySendAppTransactionBridge(algod, create.from, create.args, create, {
+            sender: transaction.getSenderAddress(create.from),
+            onComplete,
+            approvalProgram: create.approvalProgram,
+            clearStateProgram: create.clearStateProgram,
+            method: create.args.method instanceof ABIMethod ? create.args.method : new ABIMethod(create.args.method),
+            extraProgramPages: create.schema.extraPages,
+            schema: create.schema,
+        }, (c) => c.appCreateMethodCall, (c) => c.appCreateMethodCall)
+        : await legacyBridge.legacySendAppTransactionBridge(algod, create.from, create.args, create, {
+            sender: transaction.getSenderAddress(create.from),
+            onComplete,
+            approvalProgram: create.approvalProgram,
+            clearStateProgram: create.clearStateProgram,
+            extraProgramPages: create.schema.extraPages,
+            schema: create.schema,
+        }, (c) => c.appCreate, (c) => c.appCreate);
+    return {
+        ...result,
+        appId: 'appId' in result ? Number(result.appId) : 0,
+        appAddress: 'appAddress' in result ? result.appAddress.toString() : '',
+    };
 }
 /**
+ * @deprecated Use `algorand.send.appUpdate()` / `algorand.createTransaction.appUpdate()` / `algorand.send.appUpdateMethodCall()`
+ * / `algorand.createTransaction.appUpdateMethodCall()` instead
+ *
  * Updates a smart contract app.
  * @param update The parameters to update the app with
  * @param algod An algod client
  * @returns The transaction send result and the compilation result
  */
 async function updateApp(update, algod) {
-    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;
-    config.Config.getLogger(sendParams.suppressLog).debug(`Updating app ${appId}`);
-    if (args && args.method) {
-        const atc = attachATC(sendParams);
-        const before = transaction.getAtomicTransactionComposerTransactions(atc);
-        atc.addMethodCall({
-            appID: util.toNumber(appId),
-            onComplete: OnApplicationComplete.UpdateApplicationOC,
-            approvalProgram: approvalProgram,
-            clearProgram: clearProgram,
-            suggestedParams: transaction.controlFees(await transaction.getTransactionParams(transactionParams, algod), sendParams),
-            note: transaction.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 transaction.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$1 = algosdk.makeApplicationUpdateTxnFromObject({
-            appIndex: util.toNumber(appId),
-            approvalProgram: approvalProgram,
-            clearProgram: clearProgram,
-            suggestedParams: await transaction.getTransactionParams(transactionParams, algod),
-            from: transaction.getSenderAddress(from),
-            note: transaction.encodeTransactionNote(note),
-            ...getAppArgsForTransaction(args),
-            rekeyTo: args?.rekeyTo ? (typeof args.rekeyTo === 'string' ? args.rekeyTo : transaction.getSenderAddress(args.rekeyTo)) : undefined,
-        });
-        const result = await transaction.sendTransaction({ transaction: transaction$1, from, sendParams }, algod);
-        return {
-            ...result,
-            transactions: [result.transaction],
-            confirmations: result.confirmation ? [result.confirmation] : undefined,
-            return: getABIReturn(args, result.confirmation),
-            compiledApproval,
-            compiledClear,
-        };
-    }
-}
-function attachATC(sendParams) {
-    if (sendParams.atc) {
-        sendParams.skipSending = true;
-    }
-    sendParams.atc = sendParams.atc ?? new AtomicTransactionComposer();
-    return sendParams.atc;
+    return update.args?.method
+        ? await legacyBridge.legacySendAppTransactionBridge(algod, update.from, update.args, update, {
+            appId: BigInt(update.appId),
+            sender: transaction.getSenderAddress(update.from),
+            onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
+            approvalProgram: update.approvalProgram,
+            clearStateProgram: update.clearStateProgram,
+            method: update.args.method instanceof ABIMethod ? update.args.method : new ABIMethod(update.args.method),
+        }, (c) => c.appUpdateMethodCall, (c) => c.appUpdateMethodCall)
+        : await legacyBridge.legacySendAppTransactionBridge(algod, update.from, update.args, update, {
+            appId: BigInt(update.appId),
+            sender: transaction.getSenderAddress(update.from),
+            onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
+            approvalProgram: update.approvalProgram,
+            clearStateProgram: update.clearStateProgram,
+        }, (c) => c.appUpdate, (c) => c.appUpdate);
 }
-/** Returns an `algosdk.OnApplicationComplete` for the given onCompleteAction.
+/**
+ * @deprecated Use `algosdk.OnApplicationComplete` directly instead.
+ *
+ * Returns a `algosdk.OnApplicationComplete` for the given onCompleteAction.
  *
  * If given `undefined` will return `OnApplicationComplete.NoOpOC`.
  *
@@ -226,77 +109,39 @@ function getAppOnCompleteAction(onCompletionAction) {
     }
 }
 /**
+ * @deprecated Use `algorand.send.appUpdate()` / `algorand.createTransaction.appUpdate()` / `algorand.send.appUpdateMethodCall()`
+ * / `algorand.createTransaction.appUpdateMethodCall()` instead
+ *
  * Issues a call to a given app.
  * @param call The call details.
  * @param algod An algod client
  * @returns The result of the call
  */
 async function callApp(call, algod) {
-    const { appId, callType, from, args, note, transactionParams, ...sendParams } = call;
-    if (args && args.method) {
-        const atc = attachATC(sendParams);
-        const before = transaction.getAtomicTransactionComposerTransactions(atc);
-        atc.addMethodCall({
-            appID: util.toNumber(appId),
-            suggestedParams: transaction.controlFees(await transaction.getTransactionParams(transactionParams, algod), sendParams),
-            note: transaction.encodeTransactionNote(note),
-            onComplete: getAppOnCompleteAction(callType),
-            ...(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 transaction.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 onComplete = getAppOnCompleteAction(call.callType);
+    if (onComplete === algosdk.OnApplicationComplete.UpdateApplicationOC) {
+        throw new Error('Cannot execute an app call with on-complete action of Update');
     }
-    const appCallParams = {
-        appIndex: util.toNumber(appId),
-        from: transaction.getSenderAddress(from),
-        suggestedParams: await transaction.getTransactionParams(transactionParams, algod),
-        ...getAppArgsForTransaction(args),
-        note: transaction.encodeTransactionNote(note),
-        rekeyTo: args?.rekeyTo ? (typeof args.rekeyTo === 'string' ? args.rekeyTo : transaction.getSenderAddress(args.rekeyTo)) : undefined,
-    };
-    let transaction$1;
-    switch (getAppOnCompleteAction(callType)) {
-        case OnApplicationComplete.OptInOC:
-            transaction$1 = algosdk.makeApplicationOptInTxnFromObject(appCallParams);
-            break;
-        case OnApplicationComplete.ClearStateOC:
-            transaction$1 = algosdk.makeApplicationClearStateTxnFromObject(appCallParams);
-            break;
-        case OnApplicationComplete.CloseOutOC:
-            transaction$1 = algosdk.makeApplicationCloseOutTxnFromObject(appCallParams);
-            break;
-        case OnApplicationComplete.DeleteApplicationOC:
-            transaction$1 = algosdk.makeApplicationDeleteTxnFromObject(appCallParams);
-            break;
-        case OnApplicationComplete.NoOpOC:
-            transaction$1 = algosdk.makeApplicationNoOpTxnFromObject(appCallParams);
-            break;
-        default:
-            throw new Error(`Received unexpected call type ${callType}`);
+    if (call.args?.method && onComplete === algosdk.OnApplicationComplete.ClearStateOC) {
+        throw new Error('Cannot execute an ABI method call with on-complete action of ClearState');
     }
-    const result = await transaction.sendTransaction({ transaction: transaction$1, from, sendParams }, algod);
-    return {
-        ...result,
-        transactions: [result.transaction],
-        confirmations: result.confirmation ? [result.confirmation] : undefined,
-        return: getABIReturn(args, result.confirmation),
-    };
+    return call.args?.method
+        ? await legacyBridge.legacySendAppTransactionBridge(algod, call.from, call.args, call, {
+            appId: BigInt(call.appId),
+            sender: transaction.getSenderAddress(call.from),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onComplete: onComplete,
+            method: call.args.method instanceof ABIMethod ? call.args.method : new ABIMethod(call.args.method),
+        }, (c) => c.appCallMethodCall, (c) => c.appCallMethodCall)
+        : await legacyBridge.legacySendAppTransactionBridge(algod, call.from, call.args, call, {
+            appId: BigInt(call.appId),
+            sender: transaction.getSenderAddress(call.from),
+            onComplete,
+        }, (c) => c.appCall, (c) => c.appCall);
 }
 /**
+ * @deprecated Use `AppManager.getABIReturn` instead.
+ *
  * 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
@@ -307,43 +152,22 @@ function getABIReturn(args, confirmation) {
         return undefined;
     }
     const method = 'txnCount' in args.method ? args.method : new 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 = 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,
-            };
-    }
-    return undefined;
+    return types_appManager.AppManager.getABIReturn(confirmation, method);
 }
 /**
+ * @deprecated Use `algorand.app.getGlobalState` instead.
+ *
  * 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.globalState) {
-        throw new Error("Couldn't find global state");
-    }
-    return decodeAppState(appInfo.params.globalState);
+    return await new types_appManager.AppManager(algod).getGlobalState(BigInt(appId));
 }
 /**
+ * @deprecated Use `algorand.app.getLocalState` instead.
+ *
  * 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
@@ -351,30 +175,20 @@ async function getAppGlobalState(appId, algod) {
  * @returns The current local state for the given (app, account) combination
  */
 async function getAppLocalState(appId, account, algod) {
-    const accountAddress = typeof account === 'string' ? account : transaction.getSenderAddress(account);
-    const appInfo = modelsv2.AccountApplicationResponse.from_obj_for_encoding(await algod.accountApplicationInformation(accountAddress, util.toNumber(appId)).do());
-    if (!appInfo.appLocalState?.keyValue) {
-        throw new Error("Couldn't find local state");
-    }
-    return decodeAppState(appInfo.appLocalState.keyValue);
+    return new types_appManager.AppManager(algod).getLocalState(BigInt(appId), transaction.getSenderAddress(account));
 }
 /**
+ * @deprecated Use `algorand.app.getBoxNames` instead.
  * 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(util.toNumber(appId)).do();
-    return boxResult.boxes.map((b) => {
-        return {
-            nameRaw: b.name,
-            nameBase64: buffer.Buffer.from(b.name).toString('base64'),
-            name: buffer.Buffer.from(b.name).toString('utf-8'),
-        };
-    });
+    return new types_appManager.AppManager(algod).getBoxNames(BigInt(appId));
 }
 /**
+ * @deprecated Use `algorand.app.getBoxValue` instead.
  * 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`
@@ -382,11 +196,10 @@ async function getAppBoxNames(appId, algod) {
  * @returns The current box value as a byte array
  */
 async function getAppBoxValue(appId, boxName, algod) {
-    const name = typeof boxName === 'string' ? new Uint8Array(buffer.Buffer.from(boxName, 'utf-8')) : 'name' in boxName ? boxName.nameRaw : boxName;
-    const boxResult = await algod.getApplicationBoxByName(util.toNumber(appId), name).do();
-    return boxResult.value;
+    return new types_appManager.AppManager(algod).getBoxValue(BigInt(appId), typeof boxName !== 'string' && 'name' in boxName ? boxName.nameRaw : boxName);
 }
 /**
+ * @deprecated Use `algorand.app.getBoxValues` instead.
  * 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`
@@ -394,74 +207,50 @@ async function getAppBoxValue(appId, boxName, algod) {
  * @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)));
+    return new types_appManager.AppManager(algod).getBoxValues(BigInt(appId), boxNames.map((b) => (typeof b !== 'string' && 'name' in b ? b.nameRaw : b)));
 }
 /**
+ * @deprecated Use `algorand.app.getBoxValueFromABIType` instead.
  * 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);
+    return new types_appManager.AppManager(algod).getBoxValueFromABIType({
+        appId: BigInt(request.appId),
+        boxName: typeof request.boxName !== 'string' && 'name' in request.boxName ? request.boxName.nameRaw : request.boxName,
+        type: request.type,
+    });
 }
 /**
+ * @deprecated Use `algorand.app.getBoxValuesFromABIType` instead.
  * 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)));
+    return new types_appManager.AppManager(algod).getBoxValuesFromABIType({
+        appId: BigInt(request.appId),
+        boxNames: request.boxNames.map((b) => (typeof b !== 'string' && 'name' in b ? b.nameRaw : b)),
+        type: request.type,
+    });
 }
 /**
+ * @deprecated Use `AppManager.decodeAppState` instead.
+ *
  * 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.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 = tealValue.bytes ?? '';
-                valueRaw = buffer.Buffer.from(valueBase64, 'base64');
-                stateValues[key] = {
-                    keyRaw,
-                    keyBase64,
-                    valueRaw: new Uint8Array(valueRaw),
-                    valueBase64: valueBase64,
-                    value: valueRaw.toString('utf-8'),
-                };
-                break;
-            case 2: {
-                const value = tealValue.uint ?? 0;
-                stateValues[key] = {
-                    keyRaw,
-                    keyBase64,
-                    value,
-                };
-                break;
-            }
-            default:
-                throw new Error(`Received unknown state data type of ${dataTypeFlag}`);
-        }
-    }
-    return stateValues;
+    return types_appManager.AppManager.decodeAppState(state.map(({ key, value }) => ({ key: Buffer.from(key, 'utf-8'), value })));
 }
 /**
+ * @deprecated Use `TransactionComposer` methods to construct transactions instead.
+ *
  * 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`
@@ -480,68 +269,32 @@ function getAppArgsForTransaction(args) {
     };
 }
 /**
+ * @deprecated Use `TransactionComposer` methods to construct transactions instead.
+ *
  * 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 signer = transaction.getSenderTransactionSigner(from);
-    const methodArgs = await Promise.all(('methodArgs' in args ? args.methodArgs : args)?.map(async (a, index) => {
-        if (a === undefined) {
-            throw new Error(`Argument at position ${index} does not have a value`);
-        }
-        if (typeof a !== 'object') {
-            return a;
-        }
-        // Handle the various forms of transactions to wrangle them for ATC
-        return 'txn' in a
-            ? a
-            : a instanceof Promise
-                ? { txn: (await a).transaction, signer }
-                : 'transaction' in a
-                    ? { txn: a.transaction, signer: 'signer' in a ? transaction.getSenderTransactionSigner(a.signer) : signer }
-                    : 'txID' in a
-                        ? { txn: a, signer }
-                        : a;
-    }));
-    return {
-        method: 'txnCount' in args.method ? args.method : new ABIMethod(args.method),
-        sender: transaction.getSenderAddress(from),
-        signer: signer,
-        boxes: args.boxes?.map(getBoxReference),
-        lease: transaction.encodeLease(args.lease),
-        appForeignApps: args.apps,
-        appForeignAssets: args.assets,
-        appAccounts: args.accounts?.map(_getAccountAddress),
-        methodArgs: methodArgs,
-        rekeyTo: args?.rekeyTo ? (typeof args.rekeyTo === 'string' ? args.rekeyTo : transaction.getSenderAddress(args.rekeyTo)) : undefined,
-    };
+    return legacyBridge._getAppArgsForABICall(args, from);
 }
 /**
+ * @deprecated Use `AppManager.getBoxReference()` instead.
+ *
  * 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.decodeAddress(transaction.getSenderAddress(ref.name)).publicKey,
-    };
+    return legacyBridge._getBoxReference(box);
 }
 function _getAccountAddress(account) {
     return typeof account === 'string' ? account : algosdk.encodeAddress(account.publicKey);
 }
 /**
+ * @deprecated Use `algorand.app.getById` instead.
+ *
  * Gets the current data for the given app from algod.
  *
  * @param appId The id of the app
@@ -549,9 +302,11 @@ function _getAccountAddress(account) {
  * @returns The data about the app
  */
 async function getAppById(appId, algod) {
-    return modelsv2.Application.from_obj_for_encoding(await algod.getApplicationByID(util.toNumber(appId)).do());
+    return await algod.getApplicationByID(util.toNumber(appId)).do();
 }
 /**
+ * @deprecated Use `algorand.app.compileTeal` instead.
+ *
  * Compiles the given TEAL using algod and returns the result, including source map.
  *
  * @param algod An algod client
@@ -559,16 +314,11 @@ async function getAppById(appId, algod) {
  * @returns The information about the compiled file
  */
 async function compileTeal(tealCode, algod) {
-    const compiled = await algod.compile(tealCode).sourcemap(true).do();
-    return {
-        teal: tealCode,
-        compiled: compiled.result,
-        compiledHash: compiled.hash,
-        compiledBase64ToBytes: new Uint8Array(buffer.Buffer.from(compiled.result, 'base64')),
-        sourceMap: new SourceMap(compiled['sourcemap']),
-    };
+    return await new types_appManager.AppManager(algod).compileTeal(tealCode);
 }
 /**
+ * @deprecated Use `abiMethod.getSignature()` or `new ABIMethod(abiMethodParams).getSignature()` instead.
+ *
  * 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`