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

package/app-deploy.js

@@ -2,16 +2,18 @@
 
 var algosdk = require('algosdk');
 var app = require('./app.js');
-var config = require('./config.js');
-var indexerLookup = require('./indexer-lookup.js');
+var legacyBridge = require('./transaction/legacy-bridge.js');
 var transaction = require('./transaction/transaction.js');
+var types_algorandClientTransactionSender = require('./types/algorand-client-transaction-sender.js');
 var types_app = require('./types/app.js');
+var types_appDeployer = require('./types/app-deployer.js');
+var types_appManager = require('./types/app-manager.js');
+var types_assetManager = require('./types/asset-manager.js');
+var types_composer = require('./types/composer.js');
 
-var AtomicTransactionComposer = algosdk.AtomicTransactionComposer;
-var getApplicationAddress = algosdk.getApplicationAddress;
-var modelsv2 = algosdk.modelsv2;
-var TransactionType = algosdk.TransactionType;
 /**
+ * @deprecated Use `algorand.appDeployer.deploy` instead.
+ *
  * Idempotently deploy (create, update/delete if changed) an app against the given name via the given creator account, including deploy-time template placeholder substitutions.
  *
  * To understand the architecture decisions behind this functionality please see https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md
@@ -27,230 +29,123 @@ var TransactionType = algosdk.TransactionType;
  * @returns The app reference of the new/existing app
  */
 async function deployApp(deployment, algod, indexer) {
-    const { metadata, deployTimeParams: deployTimeParameters, onSchemaBreak, onUpdate, existingDeployments, createArgs, updateArgs, deleteArgs, createOnCompleteAction, ...appParams } = deployment;
-    if (existingDeployments && existingDeployments.creator !== transaction.getSenderAddress(appParams.from)) {
-        throw new Error(`Received invalid existingDeployments value for creator ${existingDeployments.creator} when attempting to deploy for creator ${appParams.from}`);
-    }
-    if (!existingDeployments && !indexer) {
-        throw new Error(`Didn't receive an indexer client, but also didn't receive an existingDeployments cache - one of them must be provided`);
-    }
-    config.Config.getLogger(appParams.suppressLog).info(`Idempotently deploying app "${metadata.name}" from creator ${transaction.getSenderAddress(appParams.from)} using ${appParams.approvalProgram.length} bytes of teal code and ${appParams.clearStateProgram.length} bytes of teal code`);
-    const compiledApproval = typeof appParams.approvalProgram === 'string'
-        ? await performTemplateSubstitutionAndCompile(appParams.approvalProgram, algod, deployTimeParameters, metadata)
-        : undefined;
-    appParams.approvalProgram = compiledApproval ? compiledApproval.compiledBase64ToBytes : appParams.approvalProgram;
-    const compiledClear = typeof appParams.clearStateProgram === 'string'
-        ? await performTemplateSubstitutionAndCompile(appParams.clearStateProgram, algod, deployTimeParameters)
-        : undefined;
-    appParams.clearStateProgram = compiledClear ? compiledClear.compiledBase64ToBytes : appParams.clearStateProgram;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const apps = existingDeployments ?? (await getCreatorAppsByName(appParams.from, indexer));
-    const create = async (atc) => {
-        const result = await app.createApp({
-            ...appParams,
-            onCompleteAction: createOnCompleteAction,
-            args: createArgs,
-            note: getAppDeploymentTransactionNote(metadata),
-            atc,
-            skipWaiting: false,
-        }, algod);
-        return {
-            transaction: result.transaction,
-            transactions: result.transactions,
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            confirmation: result.confirmation,
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            confirmations: result.confirmations,
-            return: result.return,
-            appId: result.appId,
-            appAddress: result.appAddress,
-            createdMetadata: metadata,
-            createdRound: Number(result.confirmation?.confirmedRound),
-            updatedRound: Number(result.confirmation?.confirmedRound),
-            ...metadata,
-            deleted: false,
-            operationPerformed: 'create',
-            compiledApproval,
-            compiledClear,
-        };
-    };
-    const existingApp = apps.apps[metadata.name];
-    if (!existingApp || existingApp.deleted) {
-        config.Config.getLogger(appParams.suppressLog).info(`App ${metadata.name} not found in apps created by ${transaction.getSenderAddress(appParams.from)}; deploying app with version ${metadata.version}.`);
-        return await create();
-    }
-    config.Config.getLogger(appParams.suppressLog).info(`Existing app ${metadata.name} found by creator ${transaction.getSenderAddress(appParams.from)}, with app id ${existingApp.appId} and version ${existingApp.version}.`);
-    const existingAppRecord = await app.getAppById(existingApp.appId, algod);
-    const existingApproval = Buffer.from(existingAppRecord.params.approvalProgram).toString('base64');
-    const existingClear = Buffer.from(existingAppRecord.params.clearStateProgram).toString('base64');
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const existingGlobalSchema = existingAppRecord.params.globalStateSchema;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const existingLocalSchema = existingAppRecord.params.localStateSchema;
-    const newGlobalSchema = new modelsv2.ApplicationStateSchema({
-        numByteSlice: appParams.schema.globalByteSlices,
-        numUint: appParams.schema.globalInts,
-    });
-    const newLocalSchema = new modelsv2.ApplicationStateSchema({
-        numByteSlice: appParams.schema.localByteSlices,
-        numUint: appParams.schema.localInts,
+    const appManager = new types_appManager.AppManager(algod);
+    const newGroup = () => new types_composer.default({
+        algod,
+        getSigner: () => transaction.getSenderTransactionSigner(deployment.from),
+        getSuggestedParams: async () => deployment.transactionParams ? { ...deployment.transactionParams } : await algod.getTransactionParams().do(),
+        appManager,
     });
-    const newApproval = Buffer.from(appParams.approvalProgram).toString('base64');
-    const newClear = Buffer.from(appParams.clearStateProgram).toString('base64');
-    const isUpdate = newApproval !== existingApproval || newClear !== existingClear;
-    const isSchemaBreak = isSchemaIsBroken(existingGlobalSchema, newGlobalSchema) || isSchemaIsBroken(existingLocalSchema, newLocalSchema);
-    const replace = async () => {
-        const atc = new AtomicTransactionComposer();
-        // Create
-        config.Config.getLogger(appParams.suppressLog).info(`Deploying a new ${metadata.name} app for ${transaction.getSenderAddress(appParams.from)}; deploying app with version ${metadata.version}.`);
-        const { transaction: createTransaction } = await create(atc);
-        const createTransactions = atc.clone().buildGroup();
-        // Delete
-        config.Config.getLogger(appParams.suppressLog).warn(`Deleting existing ${metadata.name} app with id ${existingApp.appId} from ${transaction.getSenderAddress(appParams.from)} account.`);
-        const { transaction: deleteTransaction } = await app.callApp({
-            appId: existingApp.appId,
-            callType: 'delete_application',
-            from: appParams.from,
-            args: deleteArgs,
-            transactionParams: appParams.transactionParams,
-            suppressLog: appParams.suppressLog,
-            skipSending: true,
-            atc,
-        }, algod);
-        // Ensure create and delete happen atomically
-        const { transactions, confirmations, returns } = await transaction.sendAtomicTransactionComposer({
-            atc,
-            sendParams: {
-                maxRoundsToWaitForConfirmation: appParams.maxRoundsToWaitForConfirmation,
-                skipWaiting: false,
-                suppressLog: true,
-            },
-        }, algod);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const createConfirmation = confirmations[createTransactions.length - 1];
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const deleteConfirmation = confirmations[confirmations.length - 1];
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const newAppIndex = createConfirmation.applicationIndex;
-        config.Config.getLogger(appParams.suppressLog).warn(`Sent transactions ${createTransaction.txID()} to create app with id ${newAppIndex} and ${deleteTransaction.txID()} to delete app with id ${existingApp.appId} from ${transaction.getSenderAddress(appParams.from)} account.`);
-        return {
-            transaction: createTransaction,
-            transactions: transactions,
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            confirmation: createConfirmation,
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            confirmations: confirmations,
-            return: returns?.[0],
-            deleteReturn: returns?.[1],
-            appId: newAppIndex,
-            appAddress: getApplicationAddress(newAppIndex),
-            createdMetadata: metadata,
-            createdRound: Number(createConfirmation.confirmedRound),
-            updatedRound: Number(createConfirmation.confirmedRound),
-            ...metadata,
-            deleted: false,
-            deleteResult: { transaction: deleteTransaction, confirmation: deleteConfirmation },
-            operationPerformed: 'replace',
-            compiledApproval,
-            compiledClear,
-        };
+    const deployer = new types_appDeployer.AppDeployer(appManager, new types_algorandClientTransactionSender.AlgorandClientTransactionSender(newGroup, new types_assetManager.AssetManager(algod, newGroup), appManager), indexer);
+    const createParams = {
+        approvalProgram: deployment.approvalProgram,
+        clearStateProgram: deployment.clearStateProgram,
+        sender: transaction.getSenderAddress(deployment.from),
+        accountReferences: deployment.createArgs?.accounts?.map((a) => (typeof a === 'string' ? a : algosdk.encodeAddress(a.publicKey))),
+        appReferences: deployment.createArgs?.apps?.map((a) => BigInt(a)),
+        assetReferences: deployment.createArgs?.assets?.map((a) => BigInt(a)),
+        boxReferences: deployment.createArgs?.boxes
+            ?.map(legacyBridge._getBoxReference)
+            ?.map((r) => ({ appId: BigInt(r.appIndex), name: r.name })),
+        lease: deployment.createArgs?.lease,
+        rekeyTo: deployment.createArgs?.rekeyTo ? transaction.getSenderAddress(deployment.createArgs?.rekeyTo) : undefined,
+        staticFee: deployment.fee,
+        maxFee: deployment.maxFee,
+        extraProgramPages: deployment.schema.extraPages,
+        onComplete: app.getAppOnCompleteAction(deployment.createOnCompleteAction),
+        schema: deployment.schema,
     };
-    const update = async () => {
-        config.Config.getLogger(appParams.suppressLog).info(`Updating existing ${metadata.name} app for ${transaction.getSenderAddress(appParams.from)} to version ${metadata.version}.`);
-        const result = await app.updateApp({
-            appId: existingApp.appId,
-            from: appParams.from,
-            args: updateArgs,
-            note: getAppDeploymentTransactionNote(metadata),
-            approvalProgram: appParams.approvalProgram,
-            clearStateProgram: appParams.clearStateProgram,
-            transactionParams: appParams.transactionParams,
-            suppressLog: appParams.suppressLog,
-            skipSending: false,
-            skipWaiting: false,
-        }, algod);
-        return {
-            transaction: result.transaction,
-            transactions: result.transactions,
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            confirmation: result.confirmation,
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            confirmations: result.confirmations,
-            return: result.return,
-            appId: existingApp.appId,
-            appAddress: existingApp.appAddress,
-            createdMetadata: existingApp.createdMetadata,
-            createdRound: existingApp.createdRound,
-            updatedRound: Number(result.confirmation?.confirmedRound),
-            ...metadata,
-            deleted: false,
-            operationPerformed: 'update',
-            compiledApproval,
-            compiledClear,
-        };
+    const updateParams = {
+        approvalProgram: deployment.approvalProgram,
+        clearStateProgram: deployment.clearStateProgram,
+        sender: transaction.getSenderAddress(deployment.from),
+        accountReferences: deployment.updateArgs?.accounts?.map((a) => (typeof a === 'string' ? a : algosdk.encodeAddress(a.publicKey))),
+        appReferences: deployment.updateArgs?.apps?.map((a) => BigInt(a)),
+        assetReferences: deployment.updateArgs?.assets?.map((a) => BigInt(a)),
+        boxReferences: deployment.updateArgs?.boxes
+            ?.map(legacyBridge._getBoxReference)
+            ?.map((r) => ({ appId: BigInt(r.appIndex), name: r.name })),
+        lease: deployment.updateArgs?.lease,
+        rekeyTo: deployment.updateArgs?.rekeyTo ? transaction.getSenderAddress(deployment.updateArgs?.rekeyTo) : undefined,
+        staticFee: deployment.fee,
+        maxFee: deployment.maxFee,
+        onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
     };
-    if (isSchemaBreak) {
-        config.Config.getLogger(appParams.suppressLog).warn(`Detected a breaking app schema change in app ${existingApp.appId}:`, {
-            from: {
-                global: existingGlobalSchema,
-                local: existingLocalSchema,
-            },
-            to: {
-                global: newGlobalSchema,
-                local: newLocalSchema,
-            },
-        });
-        if (onSchemaBreak === undefined || onSchemaBreak === 'fail' || onSchemaBreak === types_app.OnSchemaBreak.Fail) {
-            throw new Error('Schema break detected and onSchemaBreak=OnSchemaBreak.Fail, stopping deployment. ' +
-                'If you want to try deleting and recreating the app then ' +
-                're-run with onSchemaBreak=OnSchemaBreak.ReplaceApp');
-        }
-        if (onSchemaBreak === 'append' || onSchemaBreak === types_app.OnSchemaBreak.AppendApp) {
-            config.Config.getLogger(appParams.suppressLog).info('onSchemaBreak=AppendApp, will attempt to create a new app');
-            return await create();
-        }
-        if (existingApp.deletable) {
-            config.Config.getLogger(appParams.suppressLog).info('App is deletable and onSchemaBreak=ReplaceApp, will attempt to create new app and delete old app');
-        }
-        else {
-            config.Config.getLogger(appParams.suppressLog).info('App is not deletable but onSchemaBreak=ReplaceApp, will attempt to delete app, delete will most likely fail');
-        }
-        return await replace();
-    }
-    if (isUpdate) {
-        config.Config.getLogger(appParams.suppressLog).info(`Detected a TEAL update in app ${existingApp.appId} for creator ${transaction.getSenderAddress(appParams.from)}`);
-        if (onUpdate === undefined || onUpdate === 'fail' || onUpdate === types_app.OnUpdate.Fail) {
-            throw new Error('Update detected and onUpdate=Fail, stopping deployment. ' +
-                'If you want to try deleting and recreating the app then ' +
-                're-run with onUpdate=UpdateApp');
-        }
-        if (onUpdate === 'append' || onUpdate === types_app.OnUpdate.AppendApp) {
-            config.Config.getLogger(appParams.suppressLog).info('onUpdate=AppendApp, will attempt to create a new app');
-            return await create();
-        }
-        if (onUpdate === 'update' || onUpdate === types_app.OnUpdate.UpdateApp) {
-            if (existingApp.updatable) {
-                config.Config.getLogger(appParams.suppressLog).info(`App is updatable and onUpdate=UpdateApp, updating app...`);
-            }
-            else {
-                config.Config.getLogger(appParams.suppressLog).warn(`App is not updatable but onUpdate=UpdateApp, will attempt to update app, update will most likely fail`);
-            }
-            return await update();
-        }
-        if (onUpdate === 'replace' || onUpdate === types_app.OnUpdate.ReplaceApp) {
-            if (existingApp.deletable) {
-                config.Config.getLogger(appParams.suppressLog).warn('App is deletable and onUpdate=ReplaceApp, creating new app and deleting old app...');
-            }
-            else {
-                config.Config.getLogger(appParams.suppressLog).warn('App is not deletable and onUpdate=ReplaceApp, will attempt to create new app and delete old app, delete will most likely fail');
+    const deleteParams = {
+        sender: transaction.getSenderAddress(deployment.from),
+        accountReferences: deployment.deleteArgs?.accounts?.map((a) => (typeof a === 'string' ? a : algosdk.encodeAddress(a.publicKey))),
+        appReferences: deployment.deleteArgs?.apps?.map((a) => BigInt(a)),
+        assetReferences: deployment.deleteArgs?.assets?.map((a) => BigInt(a)),
+        boxReferences: deployment.deleteArgs?.boxes
+            ?.map(legacyBridge._getBoxReference)
+            ?.map((r) => ({ appId: BigInt(r.appIndex), name: r.name })),
+        lease: deployment.deleteArgs?.lease,
+        rekeyTo: deployment.deleteArgs?.rekeyTo ? transaction.getSenderAddress(deployment.deleteArgs?.rekeyTo) : undefined,
+        staticFee: deployment.fee,
+        maxFee: deployment.maxFee,
+        onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC,
+    };
+    const encoder = new TextEncoder();
+    const result = await deployer.deploy({
+        createParams: deployment.createArgs?.method
+            ? ({
+                ...createParams,
+                method: 'txnCount' in deployment.createArgs.method ? deployment.createArgs.method : new algosdk.ABIMethod(deployment.createArgs.method),
+                args: (await legacyBridge._getAppArgsForABICall(deployment.createArgs, deployment.from)).methodArgs,
+            })
+            : ({
+                ...createParams,
+                args: 'appArgs' in (deployment?.createArgs ?? {})
+                    ? deployment.createArgs?.appArgs?.map((a) => (typeof a === 'string' ? encoder.encode(a) : a))
+                    : undefined,
+            }),
+        updateParams: deployment.updateArgs?.method
+            ? ({
+                ...updateParams,
+                method: 'txnCount' in deployment.updateArgs.method ? deployment.updateArgs.method : new algosdk.ABIMethod(deployment.updateArgs.method),
+                args: (await legacyBridge._getAppArgsForABICall(deployment.updateArgs, deployment.from)).methodArgs,
+            })
+            : ({
+                ...updateParams,
+                args: 'appArgs' in (deployment?.updateArgs ?? {})
+                    ? deployment.updateArgs?.appArgs?.map((a) => (typeof a === 'string' ? encoder.encode(a) : a))
+                    : undefined,
+            }),
+        deleteParams: deployment.deleteArgs?.method
+            ? ({
+                ...deleteParams,
+                method: 'txnCount' in deployment.deleteArgs.method ? deployment.deleteArgs.method : new algosdk.ABIMethod(deployment.deleteArgs.method),
+                args: (await legacyBridge._getAppArgsForABICall(deployment.deleteArgs, deployment.from)).methodArgs,
+            })
+            : ({
+                ...deleteParams,
+                args: 'appArgs' in (deployment?.deleteArgs ?? {})
+                    ? deployment.deleteArgs?.appArgs?.map((a) => (typeof a === 'string' ? encoder.encode(a) : a))
+                    : undefined,
+            }),
+        metadata: deployment.metadata,
+        deployTimeParams: deployment.deployTimeParams,
+        onSchemaBreak: deployment.onSchemaBreak,
+        onUpdate: deployment.onUpdate,
+        existingDeployments: deployment.existingDeployments
+            ? {
+                creator: deployment.existingDeployments.creator,
+                apps: Object.fromEntries(Object.entries(deployment.existingDeployments.apps).map(([name, app]) => [
+                    name,
+                    { ...app, appId: BigInt(app.appId), createdRound: BigInt(app.createdRound), updatedRound: BigInt(app.updatedRound) },
+                ])),
             }
-            return await replace();
-        }
-    }
-    config.Config.getLogger(appParams.suppressLog).debug('No detected changes in app, nothing to do.');
-    return { ...existingApp, operationPerformed: 'nothing', compiledApproval, compiledClear };
+            : undefined,
+        maxRoundsToWaitForConfirmation: deployment.maxRoundsToWaitForConfirmation,
+        populateAppCallResources: deployment.populateAppCallResources,
+        suppressLog: deployment.suppressLog,
+    });
+    return { ...result, appId: Number(result.appId), createdRound: Number(result.createdRound), updatedRound: Number(result.updatedRound) };
 }
-/** Returns true is there is a breaking change in the application state schema from before to after.
+/**
+ * @deprecated Use `before.numByteSlice < after.numByteSlice || before.numUint < after.numUint` instead.
+ *
+ * Returns true is there is a breaking change in the application state schema from before to after.
  *  i.e. if the schema becomes larger, since applications can't ask for more schema after creation.
  *  Otherwise, there is no error, the app just doesn't store data in the extra schema :(
  *
@@ -262,6 +157,8 @@ function isSchemaIsBroken(before, after) {
     return before.numByteSlice < after.numByteSlice || before.numUint < after.numUint;
 }
 /**
+ * @deprecated Use `algorand.appDeployer.getCreatorAppsByName` instead.
+ *
  * Returns a lookup of name => app metadata (id, address, ...metadata) for all apps created by the given account that have an `AppDeployNote` in the transaction note of the creation transaction.
  *
  * **Note:** It's recommended this is only called once and then stored since it's a somewhat expensive operation (multiple indexer calls).
@@ -271,87 +168,18 @@ function isSchemaIsBroken(before, after) {
  * @returns A name-based lookup of the app information (id, address)
  */
 async function getCreatorAppsByName(creatorAccount, indexer) {
-    const appLookup = {};
-    const creatorAddress = typeof creatorAccount !== 'string' ? transaction.getSenderAddress(creatorAccount) : creatorAccount;
-    // Extract all apps that account created
-    const createdApps = (await indexerLookup.lookupAccountCreatedApplicationByAddress(indexer, creatorAddress))
-        .map((a) => {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return { id: a.id, createdAtRound: a['created-at-round'], deleted: a.deleted };
-    })
-        .sort((a, b) => a.createdAtRound - b.createdAtRound);
-    // For each app that account created (in parallel)...
-    const apps = await Promise.all(createdApps.map(async (createdApp) => {
-        // Find any app transactions for that app in the round it was created (should always just be a single creation transaction)
-        const appTransactions = await indexerLookup.searchTransactions(indexer, (s) => s
-            .minRound(createdApp.createdAtRound)
-            .txType(TransactionType.appl)
-            .applicationID(createdApp.id)
-            .address(creatorAddress)
-            .addressRole('sender')
-            .notePrefix(Buffer.from(types_app.APP_DEPLOY_NOTE_DAPP).toString('base64')));
-        // Triple check the transaction is intact by filtering for the one we want:
-        //  * application-id is 0 when the app is first created
-        //  * also verify the sender to prevent a potential security risk
-        const appCreationTransaction = appTransactions.transactions.filter(
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        (t) => t['application-transaction']['application-id'] === 0 && t.sender === creatorAddress)[0];
-        const latestAppUpdateTransaction = appTransactions.transactions
-            .filter((t) => t.sender === creatorAddress)
-            .sort((a, b) => a['confirmed-round'] === b['confirmed-round']
-            ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                (b['intra-round-offset'] - a['intra-round-offset']) / 10
-            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                b['confirmed-round'] - a['confirmed-round'])[0];
-        if (!appCreationTransaction?.note)
-            // No note; ignoring
-            return null;
-        return { createdApp, appCreationTransaction, latestAppUpdateTransaction };
-    }));
-    apps
-        .filter((a) => a !== null)
-        .forEach((a) => {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const { createdApp, appCreationTransaction, latestAppUpdateTransaction } = a;
-        const parseNote = (note) => {
-            if (!note) {
-                // No note; ignoring...
-                return;
-            }
-            const decoder = new TextDecoder();
-            const noteAsBase64 = decoder.decode(Buffer.from(note));
-            const noteAsString = Buffer.from(noteAsBase64, 'base64').toString('utf-8');
-            if (!noteAsString.startsWith(`${types_app.APP_DEPLOY_NOTE_DAPP}:j{`))
-                // Clearly not APP_DEPLOY JSON; ignoring...
-                return;
-            return JSON.parse(noteAsString.substring(types_app.APP_DEPLOY_NOTE_DAPP.length + 2));
-        };
-        try {
-            const creationNote = parseNote(appCreationTransaction.note);
-            const updateNote = parseNote(latestAppUpdateTransaction.note);
-            if (creationNote?.name) {
-                appLookup[creationNote.name] = {
-                    appId: createdApp.id,
-                    appAddress: getApplicationAddress(createdApp.id),
-                    createdMetadata: creationNote,
-                    createdRound: Number(appCreationTransaction['confirmed-round']),
-                    ...(updateNote ?? creationNote),
-                    updatedRound: Number(latestAppUpdateTransaction?.['confirmed-round']),
-                    deleted: createdApp.deleted ?? false,
-                };
-            }
-        }
-        catch (e) {
-            config.Config.logger.warn(`Received error trying to retrieve app with ${createdApp.id} for creator ${creatorAddress}; failing silently`, e);
-            return;
-        }
-    });
+    const lookup = await new types_appDeployer.AppDeployer(undefined, undefined, indexer).getCreatorAppsByName(transaction.getSenderAddress(creatorAccount));
     return {
-        creator: creatorAddress,
-        apps: appLookup,
+        creator: lookup.creator,
+        apps: Object.fromEntries(Object.entries(lookup.apps).map(([name, app]) => [
+            name,
+            { ...app, appId: Number(app.appId), createdRound: Number(app.createdRound), updatedRound: Number(app.updatedRound) },
+        ])),
     };
 }
 /**
+ * @deprecated Use `{ dAppName: APP_DEPLOY_NOTE_DAPP, data: metadata, format: 'j' }` instead.
+ *
  * Return the transaction note for an app deployment.
  * @param metadata The metadata of the deployment
  * @returns The transaction note as a utf-8 string
@@ -364,6 +192,8 @@ function getAppDeploymentTransactionNote(metadata) {
     };
 }
 /**
+ * @deprecated Use `AppManager.replaceTealTemplateDeployTimeControlParams` instead
+ *
  * Replaces deploy-time deployment control parameters within the given teal code.
  *
  * * `TMPL_UPDATABLE` for updatability / immutability control
@@ -377,21 +207,11 @@ function getAppDeploymentTransactionNote(metadata) {
  * @returns The replaced TEAL code
  */
 function replaceDeployTimeControlParams(tealCode, params) {
-    if (params.updatable !== undefined) {
-        if (!tealCode.includes(types_app.UPDATABLE_TEMPLATE_NAME)) {
-            throw new Error(`Deploy-time updatability control requested for app deployment, but ${types_app.UPDATABLE_TEMPLATE_NAME} not present in TEAL code`);
-        }
-        tealCode = tealCode.replace(new RegExp(types_app.UPDATABLE_TEMPLATE_NAME, 'g'), (params.updatable ? 1 : 0).toString());
-    }
-    if (params.deletable !== undefined) {
-        if (!tealCode.includes(types_app.DELETABLE_TEMPLATE_NAME)) {
-            throw new Error(`Deploy-time deletability control requested for app deployment, but ${types_app.DELETABLE_TEMPLATE_NAME} not present in TEAL code`);
-        }
-        tealCode = tealCode.replace(new RegExp(types_app.DELETABLE_TEMPLATE_NAME, 'g'), (params.deletable ? 1 : 0).toString());
-    }
-    return tealCode;
+    return types_appManager.AppManager.replaceTealTemplateDeployTimeControlParams(tealCode, params);
 }
 /**
+ * @deprecated Use `AppManager.replaceTealTemplateParams` instead
+ *
  * Performs template substitution of a teal file.
  *
  * Looks for `TMPL_{parameter}` for template replacements.
@@ -401,26 +221,11 @@ function replaceDeployTimeControlParams(tealCode, params) {
  * @returns The TEAL code with replacements
  */
 function performTemplateSubstitution(tealCode, templateParams) {
-    if (templateParams !== undefined) {
-        for (const key in templateParams) {
-            const value = templateParams[key];
-            const token = `TMPL_${key.replace(/^TMPL_/, '')}`;
-            // If this is a number, first replace any byte representations of the number
-            // These may appear in the TEAL in order to circumvent int compression and preserve PC values
-            if (typeof value === 'number' || typeof value === 'boolean') {
-                tealCode = tealCode.replace(new RegExp(`(?<=bytes )${token}`, 'g'), `0x${value.toString(16).padStart(16, '0')}`);
-                // We could probably return here since mixing pushint and pushbytes is likely not going to happen, but might as well do both
-            }
-            tealCode = tealCode.replace(new RegExp(token, 'g'), typeof value === 'string'
-                ? `0x${Buffer.from(value, 'utf-8').toString('hex')}`
-                : ArrayBuffer.isView(value)
-                    ? `0x${Buffer.from(value).toString('hex')}`
-                    : value.toString());
-        }
-    }
-    return tealCode;
+    return types_appManager.AppManager.replaceTealTemplateParams(tealCode, templateParams);
 }
 /**
+ * @deprecated Use `algorand.appManager.compileTealTemplate` instead.
+ *
  * Performs template substitution of a teal file and compiles it, returning the compiled result.
  *
  * Looks for `TMPL_{parameter}` for template replacements.
@@ -440,6 +245,8 @@ async function performTemplateSubstitutionAndCompile(tealCode, algod, templatePa
     return await app.compileTeal(tealCode, algod);
 }
 /**
+ * @deprecated Use `AppManager.stripTealComments` instead.
+ *
  * Remove comments from TEAL Code
  *
  * @param tealCode The TEAL logic to compile