@algorandfoundation/algokit-client-generator 2.6.0 → 2.6.1-beta.1

package/client/{call-composer-types.js → call-composer-types.mjs}

@@ -1,45 +1,20 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callComposerType = void 0;
-const writer_1 = require("../output/writer");
-const algokit = __importStar(require("@algorandfoundation/algokit-utils"));
-const sanitization_1 = require("../util/sanitization");
-const get_call_config_summary_1 = require("./helpers/get-call-config-summary");
-const deploy_types_1 = require("./deploy-types");
+import { IncIndent, jsDoc, DecIndentAndCloseBlock, NewLine } from '../output/writer.mjs';
+import * as algokit from '@algorandfoundation/algokit-utils';
+import { makeSafeMethodIdentifier } from '../util/sanitization.mjs';
+import { BARE_CALL } from './helpers/get-call-config-summary.mjs';
+import { getCreateOnCompleteOptions } from './deploy-types.mjs';
+
 function* callComposerType(ctx) {
     const { name, callConfig, app } = ctx;
     yield `export type ${name}Composer<TReturns extends [...any[]] = []> = {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield* callComposerTypeNoops(ctx);
     yield* callComposerOperationMethodType(ctx, `Updates an existing instance of the ${app.contract.name} smart contract`, callConfig.updateMethods, 'update', true);
     yield* callComposerOperationMethodType(ctx, `Deletes an existing instance of the ${app.contract.name} smart contract`, callConfig.deleteMethods, 'delete');
     yield* callComposerOperationMethodType(ctx, `Opts the user into an existing instance of the ${app.contract.name} smart contract`, callConfig.optInMethods, 'optIn');
     yield* callComposerOperationMethodType(ctx, `Makes a close out call to an existing instance of the ${app.contract.name} smart contract`, callConfig.closeOutMethods, 'closeOut');
     yield* callComposerTypeClearState(ctx);
-    yield* (0, writer_1.jsDoc)({
+    yield* jsDoc({
         description: 'Adds a transaction to the composer',
         params: {
             txn: 'One of: A TransactionWithSigner object (returned as is), a TransactionToSign object (signer is obtained from the signer property), a Transaction object (signer is extracted from the defaultSender parameter), an async SendTransactionResult returned by one of algokit utils helpers (signer is obtained from the defaultSender parameter)',
@@ -48,37 +23,36 @@ function* callComposerType(ctx) {
         },
     });
     yield `addTransaction(txn: TransactionWithSigner | TransactionToSign | Transaction | Promise<SendTransactionResult>, defaultSender?: SendTransactionFrom): ${name}Composer<TReturns>`;
-    yield* (0, writer_1.jsDoc)({
+    yield* jsDoc({
         description: 'Returns the underlying AtomicTransactionComposer instance',
     });
     yield `atc(): Promise<AtomicTransactionComposer>`;
-    yield* (0, writer_1.jsDoc)({
+    yield* jsDoc({
         description: 'Simulates the transaction group and returns the result',
     });
     yield `simulate(options?: SimulateOptions): Promise<${name}ComposerSimulateResult<TReturns>>`;
-    yield* (0, writer_1.jsDoc)({
+    yield* jsDoc({
         description: 'Executes the transaction group and returns the results',
     });
     yield `execute(sendParams?: AppClientComposeExecuteParams): Promise<${name}ComposerResults<TReturns>>`;
-    yield writer_1.DecIndentAndCloseBlock;
+    yield DecIndentAndCloseBlock;
     yield `export type SimulateOptions = Omit<ConstructorParameters<typeof modelsv2.SimulateRequest>[0], 'txnGroups'>`;
     yield `export type ${name}ComposerSimulateResult<TReturns extends [...any[]]> = {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield `returns: TReturns`;
     yield `methodResults: ABIResult[]`;
     yield `simulateResponse: modelsv2.SimulateResponse`;
-    yield writer_1.DecIndentAndCloseBlock;
+    yield DecIndentAndCloseBlock;
     yield `export type ${name}ComposerResults<TReturns extends [...any[]]> = {`;
-    yield writer_1.IncIndent;
+    yield IncIndent;
     yield `returns: TReturns`;
     yield `groupId: string`;
     yield `txIds: string[]`;
     yield `transactions: Transaction[]`;
-    yield writer_1.DecIndentAndCloseBlock;
+    yield DecIndentAndCloseBlock;
 }
-exports.callComposerType = callComposerType;
 function* callComposerTypeClearState({ app, name }) {
-    yield* (0, writer_1.jsDoc)({
+    yield* jsDoc({
         description: `Makes a clear_state call to an existing instance of the ${app.contract.name} smart contract.`,
         params: {
             args: `The arguments for the bare call`,
@@ -86,16 +60,16 @@ function* callComposerTypeClearState({ app, name }) {
         returns: `The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions`,
     });
     yield `clearState(args?: BareCallArgs & AppClientComposeCallCoreParams & CoreAppCallArgs): ${name}Composer<[...TReturns, undefined]>`;
-    yield writer_1.NewLine;
+    yield NewLine;
 }
 function* callComposerTypeNoops({ app, name, callConfig, methodSignatureToUniqueName }) {
     for (const method of app.contract.methods) {
         const methodSignature = algokit.getABIMethodSignature(method);
-        const methodName = (0, sanitization_1.makeSafeMethodIdentifier)(methodSignatureToUniqueName[methodSignature]);
+        const methodName = makeSafeMethodIdentifier(methodSignatureToUniqueName[methodSignature]);
         // Skip methods which don't support a no_op call config
         if (!callConfig.callMethods.includes(methodSignature))
             continue;
-        yield* (0, writer_1.jsDoc)({
+        yield* jsDoc({
             description: `Calls the ${algokit.getABIMethodSignature(method)} ABI method.`,
             abiDescription: method.desc,
             params: {
@@ -105,29 +79,29 @@ function* callComposerTypeNoops({ app, name, callConfig, methodSignatureToUnique
             returns: `The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions`,
         });
         yield `${methodName}(args: MethodArgs<'${methodSignature}'>, params?: AppClientComposeCallCoreParams & CoreAppCallArgs): ${name}Composer<[...TReturns, MethodReturn<'${methodSignature}'>]>`;
-        yield writer_1.NewLine;
+        yield NewLine;
     }
 }
 function* callComposerOperationMethodType({ app, methodSignatureToUniqueName, name }, description, methods, verb, includeCompilation) {
     if (methods.length) {
-        yield* (0, writer_1.jsDoc)(`Gets available ${verb} methods`);
+        yield* jsDoc(`Gets available ${verb} methods`);
         yield `readonly ${verb}: {`;
-        yield writer_1.IncIndent;
+        yield IncIndent;
         for (const methodSig of methods) {
-            const onComplete = verb === 'create' ? (0, deploy_types_1.getCreateOnCompleteOptions)(methodSig, app) : undefined;
-            if (methodSig === get_call_config_summary_1.BARE_CALL) {
-                yield* (0, writer_1.jsDoc)({
+            const onComplete = verb === 'create' ? getCreateOnCompleteOptions(methodSig, app) : undefined;
+            if (methodSig === BARE_CALL) {
+                yield* jsDoc({
                     description: `${description} using a bare call.`,
                     params: {
                         args: `The arguments for the bare call`,
                     },
                     returns: `The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions`,
                 });
-                yield `bare(args${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.isOptional) !== false ? '?' : ''}: BareCallArgs & AppClientComposeCallCoreParams ${includeCompilation ? '& AppClientCompilationParams ' : ''}& CoreAppCallArgs${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.type) ? ` & ${onComplete.type}` : ''}): ${name}Composer<[...TReturns, undefined]>`;
+                yield `bare(args${onComplete?.isOptional !== false ? '?' : ''}: BareCallArgs & AppClientComposeCallCoreParams ${includeCompilation ? '& AppClientCompilationParams ' : ''}& CoreAppCallArgs${onComplete?.type ? ` & ${onComplete.type}` : ''}): ${name}Composer<[...TReturns, undefined]>`;
             }
             else {
                 const uniqueName = methodSignatureToUniqueName[methodSig];
-                yield* (0, writer_1.jsDoc)({
+                yield* jsDoc({
                     description: `${description} using the ${methodSig} ABI method.`,
                     params: {
                         args: `The arguments for the smart contract call`,
@@ -135,11 +109,12 @@ function* callComposerOperationMethodType({ app, methodSignatureToUniqueName, na
                     },
                     returns: `The typed transaction composer so you can fluently chain multiple calls or call execute to execute all queued up transactions`,
                 });
-                yield `${(0, sanitization_1.makeSafeMethodIdentifier)(uniqueName)}(args: MethodArgs<'${methodSig}'>, params${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.isOptional) !== false ? '?' : ''}: AppClientComposeCallCoreParams${includeCompilation ? ' & AppClientCompilationParams' : ''}${(onComplete === null || onComplete === void 0 ? void 0 : onComplete.type) ? ` & ${onComplete.type}` : ''}): ${name}Composer<[...TReturns, MethodReturn<'${methodSig}'>]>`;
+                yield `${makeSafeMethodIdentifier(uniqueName)}(args: MethodArgs<'${methodSig}'>, params${onComplete?.isOptional !== false ? '?' : ''}: AppClientComposeCallCoreParams${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}): ${name}Composer<[...TReturns, MethodReturn<'${methodSig}'>]>`;
             }
         }
-        yield writer_1.DecIndentAndCloseBlock;
-        yield writer_1.NewLine;
+        yield DecIndentAndCloseBlock;
+        yield NewLine;
     }
 }
-//# sourceMappingURL=call-composer-types.js.map
+
+export { callComposerType };

package/client/call-composer.cjs

@@ -0,0 +1,145 @@
+'use strict';
+
+var writer = require('../output/writer.cjs');
+var algokit = require('@algorandfoundation/algokit-utils');
+var sanitization = require('../util/sanitization.cjs');
+var getCallConfigSummary = require('./helpers/get-call-config-summary.cjs');
+var deployTypes = require('./deploy-types.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var algokit__namespace = /*#__PURE__*/_interopNamespaceDefault(algokit);
+
+function* composeMethod(ctx) {
+    const { name, callConfig } = ctx;
+    yield `public compose(): ${name}Composer {`;
+    yield writer.IncIndent;
+    yield `const client = this`;
+    yield `const atc = new AtomicTransactionComposer()`;
+    yield `let promiseChain:Promise<unknown> = Promise.resolve()`;
+    yield `const resultMappers: Array<undefined | ((x: any) => any)> = []`;
+    yield `return {`;
+    yield writer.IncIndent;
+    yield* callComposerNoops(ctx);
+    yield* callComposerOperationMethods(ctx, callConfig.updateMethods, 'update', true);
+    yield* callComposerOperationMethods(ctx, callConfig.deleteMethods, 'delete');
+    yield* callComposerOperationMethods(ctx, callConfig.optInMethods, 'optIn');
+    yield* callComposerOperationMethods(ctx, callConfig.closeOutMethods, 'closeOut');
+    yield* callComposerClearState();
+    yield `addTransaction(txn: TransactionWithSigner | TransactionToSign | Transaction | Promise<SendTransactionResult>, defaultSender?: SendTransactionFrom) {`;
+    yield writer.IncIndent;
+    yield 'promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit.getTransactionWithSigner(txn, defaultSender ??' +
+        ' client.sender)))';
+    yield 'return this';
+    yield writer.DecIndent;
+    yield '},';
+    yield `async atc() {`;
+    yield writer.IncIndent;
+    yield 'await promiseChain';
+    yield 'return atc';
+    yield writer.DecIndent;
+    yield '},';
+    yield `async simulate(options?: SimulateOptions) {`;
+    yield writer.IncIndent;
+    yield `await promiseChain`;
+    yield `const result = await atc.simulate(client.algod, new modelsv2.SimulateRequest({ txnGroups: [], ...options }))`;
+    yield `return {`;
+    yield writer.IncIndent;
+    yield `...result,`;
+    yield `returns: result.methodResults?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i]!(val.returnValue) : val.returnValue)`;
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.DecIndent;
+    yield '},';
+    yield `async execute(sendParams?: AppClientComposeExecuteParams) {`;
+    yield writer.IncIndent;
+    yield `await promiseChain`;
+    yield `const result = await algokit.sendAtomicTransactionComposer({ atc, sendParams }, client.algod)`;
+    yield `return {`;
+    yield writer.IncIndent;
+    yield `...result,`;
+    yield `returns: result.returns?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i]!(val.returnValue) : val.returnValue)`;
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.DecIndentAndCloseBlock;
+    yield writer.DecIndent;
+    yield `} as unknown as ${name}Composer`;
+    yield writer.DecIndentAndCloseBlock;
+}
+function* callComposerNoops({ app, callConfig, methodSignatureToUniqueName }) {
+    for (const method of app.contract.methods) {
+        const methodSignature = algokit__namespace.getABIMethodSignature(method);
+        const methodName = sanitization.makeSafeMethodIdentifier(methodSignatureToUniqueName[methodSignature]);
+        // Skip methods which don't support a no_op call config
+        if (!callConfig.callMethods.includes(methodSignature))
+            continue;
+        yield `${methodName}(args: MethodArgs<'${methodSignature}'>, params?: AppClientComposeCallCoreParams & CoreAppCallArgs) {`;
+        yield writer.IncIndent;
+        yield `promiseChain = promiseChain.then(() => client.${methodName}(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}}))`;
+        const outputTypeName = app.hints?.[methodSignature]?.structs?.output?.name;
+        yield `resultMappers.push(${outputTypeName ?? 'undefined'})`;
+        yield `return this`;
+        yield writer.DecIndent;
+        yield '},';
+    }
+}
+function* callComposerClearState() {
+    yield `clearState(args?: BareCallArgs & AppClientComposeCallCoreParams & CoreAppCallArgs) {`;
+    yield writer.IncIndent;
+    yield `promiseChain = promiseChain.then(() => client.clearState({...args, sendParams: {...args?.sendParams, skipSending: true, atc}}))`;
+    yield `resultMappers.push(undefined)`;
+    yield `return this`;
+    yield writer.DecIndent;
+    yield '},';
+}
+function* callComposerOperationMethods({ app, methodSignatureToUniqueName }, methods, verb, includeCompilation) {
+    if (methods.length) {
+        yield `get ${verb}() {`;
+        yield writer.IncIndent;
+        yield `const $this = this`;
+        yield `return {`;
+        yield writer.IncIndent;
+        for (const methodSig of methods) {
+            const onComplete = verb === 'create' ? deployTypes.getCreateOnCompleteOptions(methodSig, app) : undefined;
+            if (methodSig === getCallConfigSummary.BARE_CALL) {
+                yield `bare(args${onComplete?.isOptional !== false ? '?' : ''}: BareCallArgs & AppClientComposeCallCoreParams ${includeCompilation ? '& AppClientCompilationParams ' : ''}& CoreAppCallArgs${onComplete?.type ? ` & ${onComplete.type}` : ''}) {`;
+                yield writer.IncIndent;
+                yield `promiseChain = promiseChain.then(() => client.${verb}.bare({...args, sendParams: {...args?.sendParams, skipSending: true, atc}}))`;
+                yield `resultMappers.push(undefined)`;
+                yield `return $this`;
+                yield writer.DecIndent;
+                yield '},';
+            }
+            else {
+                const uniqueName = methodSignatureToUniqueName[methodSig];
+                const methodName = sanitization.makeSafeMethodIdentifier(uniqueName);
+                yield `${methodName}(args: MethodArgs<'${methodSig}'>, params${onComplete?.isOptional !== false ? '?' : ''}: AppClientComposeCallCoreParams${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}) {`;
+                yield writer.IncIndent;
+                yield `promiseChain = promiseChain.then(() => client.${verb}.${methodName}(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}}))`;
+                const outputTypeName = app.hints?.[methodSig]?.structs?.output?.name;
+                yield `resultMappers.push(${outputTypeName ?? 'undefined'})`;
+                yield `return $this`;
+                yield writer.DecIndent;
+                yield '},';
+            }
+        }
+        yield writer.DecIndentAndCloseBlock;
+        yield writer.DecIndent;
+        yield '},';
+    }
+}
+
+exports.composeMethod = composeMethod;

package/client/call-composer.d.ts

@@ -1,4 +1,3 @@
 import { DocumentParts } from '../output/writer';
 import { GeneratorContext } from './generator-context';
 export declare function composeMethod(ctx: GeneratorContext): DocumentParts;
-//# sourceMappingURL=call-composer.d.ts.map

package/client/call-composer.mjs

@@ -0,0 +1,124 @@
+import { IncIndent, DecIndent, DecIndentAndCloseBlock } from '../output/writer.mjs';
+import * as algokit from '@algorandfoundation/algokit-utils';
+import { makeSafeMethodIdentifier } from '../util/sanitization.mjs';
+import { BARE_CALL } from './helpers/get-call-config-summary.mjs';
+import { getCreateOnCompleteOptions } from './deploy-types.mjs';
+
+function* composeMethod(ctx) {
+    const { name, callConfig } = ctx;
+    yield `public compose(): ${name}Composer {`;
+    yield IncIndent;
+    yield `const client = this`;
+    yield `const atc = new AtomicTransactionComposer()`;
+    yield `let promiseChain:Promise<unknown> = Promise.resolve()`;
+    yield `const resultMappers: Array<undefined | ((x: any) => any)> = []`;
+    yield `return {`;
+    yield IncIndent;
+    yield* callComposerNoops(ctx);
+    yield* callComposerOperationMethods(ctx, callConfig.updateMethods, 'update', true);
+    yield* callComposerOperationMethods(ctx, callConfig.deleteMethods, 'delete');
+    yield* callComposerOperationMethods(ctx, callConfig.optInMethods, 'optIn');
+    yield* callComposerOperationMethods(ctx, callConfig.closeOutMethods, 'closeOut');
+    yield* callComposerClearState();
+    yield `addTransaction(txn: TransactionWithSigner | TransactionToSign | Transaction | Promise<SendTransactionResult>, defaultSender?: SendTransactionFrom) {`;
+    yield IncIndent;
+    yield 'promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit.getTransactionWithSigner(txn, defaultSender ??' +
+        ' client.sender)))';
+    yield 'return this';
+    yield DecIndent;
+    yield '},';
+    yield `async atc() {`;
+    yield IncIndent;
+    yield 'await promiseChain';
+    yield 'return atc';
+    yield DecIndent;
+    yield '},';
+    yield `async simulate(options?: SimulateOptions) {`;
+    yield IncIndent;
+    yield `await promiseChain`;
+    yield `const result = await atc.simulate(client.algod, new modelsv2.SimulateRequest({ txnGroups: [], ...options }))`;
+    yield `return {`;
+    yield IncIndent;
+    yield `...result,`;
+    yield `returns: result.methodResults?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i]!(val.returnValue) : val.returnValue)`;
+    yield DecIndentAndCloseBlock;
+    yield DecIndent;
+    yield '},';
+    yield `async execute(sendParams?: AppClientComposeExecuteParams) {`;
+    yield IncIndent;
+    yield `await promiseChain`;
+    yield `const result = await algokit.sendAtomicTransactionComposer({ atc, sendParams }, client.algod)`;
+    yield `return {`;
+    yield IncIndent;
+    yield `...result,`;
+    yield `returns: result.returns?.map((val, i) => resultMappers[i] !== undefined ? resultMappers[i]!(val.returnValue) : val.returnValue)`;
+    yield DecIndentAndCloseBlock;
+    yield DecIndentAndCloseBlock;
+    yield DecIndent;
+    yield `} as unknown as ${name}Composer`;
+    yield DecIndentAndCloseBlock;
+}
+function* callComposerNoops({ app, callConfig, methodSignatureToUniqueName }) {
+    for (const method of app.contract.methods) {
+        const methodSignature = algokit.getABIMethodSignature(method);
+        const methodName = makeSafeMethodIdentifier(methodSignatureToUniqueName[methodSignature]);
+        // Skip methods which don't support a no_op call config
+        if (!callConfig.callMethods.includes(methodSignature))
+            continue;
+        yield `${methodName}(args: MethodArgs<'${methodSignature}'>, params?: AppClientComposeCallCoreParams & CoreAppCallArgs) {`;
+        yield IncIndent;
+        yield `promiseChain = promiseChain.then(() => client.${methodName}(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}}))`;
+        const outputTypeName = app.hints?.[methodSignature]?.structs?.output?.name;
+        yield `resultMappers.push(${outputTypeName ?? 'undefined'})`;
+        yield `return this`;
+        yield DecIndent;
+        yield '},';
+    }
+}
+function* callComposerClearState() {
+    yield `clearState(args?: BareCallArgs & AppClientComposeCallCoreParams & CoreAppCallArgs) {`;
+    yield IncIndent;
+    yield `promiseChain = promiseChain.then(() => client.clearState({...args, sendParams: {...args?.sendParams, skipSending: true, atc}}))`;
+    yield `resultMappers.push(undefined)`;
+    yield `return this`;
+    yield DecIndent;
+    yield '},';
+}
+function* callComposerOperationMethods({ app, methodSignatureToUniqueName }, methods, verb, includeCompilation) {
+    if (methods.length) {
+        yield `get ${verb}() {`;
+        yield IncIndent;
+        yield `const $this = this`;
+        yield `return {`;
+        yield IncIndent;
+        for (const methodSig of methods) {
+            const onComplete = verb === 'create' ? getCreateOnCompleteOptions(methodSig, app) : undefined;
+            if (methodSig === BARE_CALL) {
+                yield `bare(args${onComplete?.isOptional !== false ? '?' : ''}: BareCallArgs & AppClientComposeCallCoreParams ${includeCompilation ? '& AppClientCompilationParams ' : ''}& CoreAppCallArgs${onComplete?.type ? ` & ${onComplete.type}` : ''}) {`;
+                yield IncIndent;
+                yield `promiseChain = promiseChain.then(() => client.${verb}.bare({...args, sendParams: {...args?.sendParams, skipSending: true, atc}}))`;
+                yield `resultMappers.push(undefined)`;
+                yield `return $this`;
+                yield DecIndent;
+                yield '},';
+            }
+            else {
+                const uniqueName = methodSignatureToUniqueName[methodSig];
+                const methodName = makeSafeMethodIdentifier(uniqueName);
+                yield `${methodName}(args: MethodArgs<'${methodSig}'>, params${onComplete?.isOptional !== false ? '?' : ''}: AppClientComposeCallCoreParams${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}) {`;
+                yield IncIndent;
+                yield `promiseChain = promiseChain.then(() => client.${verb}.${methodName}(args, {...params, sendParams: {...params?.sendParams, skipSending: true, atc}}))`;
+                const outputTypeName = app.hints?.[methodSig]?.structs?.output?.name;
+                yield `resultMappers.push(${outputTypeName ?? 'undefined'})`;
+                yield `return $this`;
+                yield DecIndent;
+                yield '},';
+            }
+        }
+        yield DecIndentAndCloseBlock;
+        yield DecIndent;
+        yield '},';
+    }
+}
+
+export { composeMethod };

package/client/call-factory.cjs

@@ -0,0 +1,138 @@
+'use strict';
+
+var writer = require('../output/writer.cjs');
+var sanitization = require('../util/sanitization.cjs');
+var algokit = require('@algorandfoundation/algokit-utils');
+var getCallConfigSummary = require('./helpers/get-call-config-summary.cjs');
+var deployTypes = require('./deploy-types.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var algokit__namespace = /*#__PURE__*/_interopNamespaceDefault(algokit);
+
+function* callFactory(ctx) {
+    yield* writer.jsDoc('Exposes methods for constructing all available smart contract calls');
+    yield `export abstract class ${ctx.name}CallFactory {`;
+    yield writer.IncIndent;
+    yield* opMethods(ctx);
+    for (const method of ctx.app.contract.methods) {
+        yield* callFactoryMethod(ctx, method);
+    }
+    yield writer.DecIndent;
+    yield '}';
+}
+function* opMethods(ctx) {
+    const { app, callConfig } = ctx;
+    yield* operationMethod(ctx, `Constructs a create call for the ${app.contract.name} smart contract`, callConfig.createMethods, 'create', true);
+    yield* operationMethod(ctx, `Constructs an update call for the ${app.contract.name} smart contract`, callConfig.updateMethods, 'update', true);
+    yield* operationMethod(ctx, `Constructs a delete call for the ${app.contract.name} smart contract`, callConfig.deleteMethods, 'delete');
+    yield* operationMethod(ctx, `Constructs an opt in call for the ${app.contract.name} smart contract`, callConfig.optInMethods, 'optIn');
+    yield* operationMethod(ctx, `Constructs a close out call for the ${app.contract.name} smart contract`, callConfig.closeOutMethods, 'closeOut');
+}
+function* operationMethod({ app, methodSignatureToUniqueName }, description, methods, verb, includeCompilation) {
+    if (methods.length) {
+        yield* writer.jsDoc(`Gets available ${verb} call factories`);
+        yield `static get ${verb}() {`;
+        yield writer.IncIndent;
+        yield `return {`;
+        yield writer.IncIndent;
+        for (const methodSig of methods) {
+            const onComplete = verb === 'create' ? deployTypes.getCreateOnCompleteOptions(methodSig, app) : undefined;
+            if (methodSig === getCallConfigSummary.BARE_CALL) {
+                yield* writer.jsDoc({
+                    description: `${description} using a bare call`,
+                    params: {
+                        params: `Any parameters for the call`,
+                    },
+                    returns: `A TypedCallParams object for the call`,
+                });
+                yield* factoryMethod({
+                    isNested: true,
+                    name: 'bare',
+                    paramTypes: `BareCallArgs & AppClientCallCoreParams & CoreAppCallArgs${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}${onComplete?.isOptional !== false ? ' = {}' : ''}`,
+                });
+            }
+            else {
+                const method = app.contract.methods.find((m) => algokit__namespace.getABIMethodSignature(m) === methodSig);
+                const uniqueName = methodSignatureToUniqueName[methodSig];
+                yield* writer.jsDoc({
+                    description: `${description} using the ${methodSig} ABI method`,
+                    params: {
+                        args: `Any args for the contract call`,
+                        params: `Any additional parameters for the call`,
+                    },
+                    returns: `A TypedCallParams object for the call`,
+                });
+                yield* factoryMethod({
+                    isNested: true,
+                    name: sanitization.makeSafeMethodIdentifier(uniqueName),
+                    signature: methodSig,
+                    args: method.args,
+                    paramTypes: `AppClientCallCoreParams & CoreAppCallArgs${includeCompilation ? ' & AppClientCompilationParams' : ''}${onComplete?.type ? ` & ${onComplete.type}` : ''}${onComplete?.isOptional !== false ? ' = {}' : ''}`,
+                });
+            }
+        }
+        yield writer.DecIndentAndCloseBlock;
+        yield writer.DecIndentAndCloseBlock;
+        yield writer.NewLine;
+    }
+}
+function* callFactoryMethod({ methodSignatureToUniqueName, callConfig }, method) {
+    const methodSignature = algokit__namespace.getABIMethodSignature(method);
+    if (!callConfig.callMethods.includes(methodSignature))
+        return;
+    yield* writer.jsDoc({
+        description: `Constructs a no op call for the ${methodSignature} ABI method`,
+        abiDescription: method.desc,
+        params: {
+            args: `Any args for the contract call`,
+            params: `Any additional parameters for the call`,
+        },
+        returns: `A TypedCallParams object for the call`,
+    });
+    yield* factoryMethod({
+        isNested: false,
+        name: sanitization.makeSafeMethodIdentifier(methodSignatureToUniqueName[methodSignature]),
+        signature: methodSignature,
+        args: method.args,
+        paramTypes: 'AppClientCallCoreParams & CoreAppCallArgs',
+    });
+}
+function* factoryMethod({ isNested, name, signature, args, paramTypes, }) {
+    yield `${isNested ? '' : 'static '}${name}(${signature === undefined ? '' : `args: MethodArgs<'${signature}'>, `}params: ${paramTypes}) {`;
+    yield writer.IncIndent;
+    yield `return {`;
+    yield writer.IncIndent;
+    if (signature) {
+        yield `method: '${signature}' as const,`;
+        yield `methodArgs: Array.isArray(args) ? args : [${args
+            .map((a) => (sanitization.isSafeVariableIdentifier(a.name) ? `args.${a.name}` : `args['${sanitization.makeSafePropertyIdentifier(a.name)}']`))
+            .join(', ')}],`;
+    }
+    else {
+        yield `method: undefined,`;
+        yield `methodArgs: undefined,`;
+    }
+    yield '...params,';
+    yield writer.DecIndent;
+    yield '}';
+    yield writer.DecIndent;
+    yield `}${isNested ? ',' : ''}`;
+}
+
+exports.callFactory = callFactory;

package/client/call-factory.d.ts

@@ -1,4 +1,3 @@
 import { DocumentParts } from '../output/writer';
 import { GeneratorContext } from './generator-context';
 export declare function callFactory(ctx: GeneratorContext): DocumentParts;
-//# sourceMappingURL=call-factory.d.ts.map