@mimicprotocol/cli 0.0.1-rc.18 → 0.0.1-rc.19

package/dist/commands/compile.js

@@ -46,23 +46,20 @@ class Compile extends core_1.Command {
     async run() {
         const { flags } = await this.parse(Compile);
         const { task: taskFile, output: outputDir, manifest: manifestDir } = flags;
-        console.log(`Compiling AssemblyScript from ${taskFile}`);
-        if (!fs.existsSync(outputDir))
-            fs.mkdirSync(outputDir, { recursive: true });
+        const absTaskFile = path.resolve(taskFile);
+        const absOutputDir = path.resolve(outputDir);
+        if (!fs.existsSync(absOutputDir))
+            fs.mkdirSync(absOutputDir, { recursive: true });
         log_1.default.startAction('Verifying Manifest');
         const manifest = ManifestHandler_1.default.load(this, manifestDir);
         log_1.default.startAction('Compiling');
-        const wasmPath = path.join(outputDir, 'task.wasm');
-        const watPath = path.join(outputDir, 'task.wat');
         const ascArgs = [
             'asc',
-            taskFile,
+            absTaskFile,
             '--target',
             'release',
             '--outFile',
-            wasmPath,
-            '--textFile',
-            watPath,
+            path.join(absOutputDir, 'task.wasm'),
             '--optimize',
             '--exportRuntime',
             '--transform',

package/dist/commands/deploy.js

@@ -38,19 +38,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const axios_1 = __importStar(require("axios"));
+const child_process_1 = require("child_process");
 const form_data_1 = __importDefault(require("form-data"));
 const fs = __importStar(require("fs"));
 const path_1 = require("path");
 const errors_1 = require("../errors");
 const log_1 = __importDefault(require("../log"));
-const MIMIC_REGISTRY = 'https://api-protocol.mimic.fi';
+const MIMIC_REGISTRY_DEFAULT = 'https://api-protocol.mimic.fi';
 class Deploy extends core_1.Command {
     async run() {
         const { flags } = await this.parse(Deploy);
-        const { key, input: inputDir, output: outputDir } = flags;
-        log_1.default.startAction('Validating');
+        const { key, input: inputDir, output: outputDir, 'skip-compile': skipCompile, url: registryUrl } = flags;
         const fullInputDir = (0, path_1.resolve)(inputDir);
         const fullOutputDir = (0, path_1.resolve)(outputDir);
+        if (!skipCompile) {
+            const codegen = (0, child_process_1.spawnSync)('yarn', ['mimic', 'codegen'], { stdio: 'inherit' });
+            if (codegen.status !== 0)
+                this.error('Code generation failed', { code: 'CodegenError', suggestions: ['Fix manifest and ABI files'] });
+            const compile = (0, child_process_1.spawnSync)('yarn', ['mimic', 'compile', '--output', fullInputDir], { stdio: 'inherit' });
+            if (compile.status !== 0)
+                this.error('Compilation failed', { code: 'BuildError', suggestions: ['Check the task source code'] });
+        }
+        log_1.default.startAction('Validating');
         if (!fs.existsSync(fullInputDir))
             this.error(`Directory ${log_1.default.highlightText(fullInputDir)} does not exist`, {
                 code: 'Directory Not Found',
@@ -65,7 +74,7 @@ class Deploy extends core_1.Command {
                 });
         }
         log_1.default.startAction('Uploading to Mimic Registry');
-        const CID = await this.uploadToRegistry(neededFiles, key);
+        const CID = await this.uploadToRegistry(neededFiles, key, registryUrl);
         console.log(`IPFS CID: ${log_1.default.highlightText(CID)}`);
         log_1.default.stopAction();
         if (!fs.existsSync(fullOutputDir))
@@ -74,10 +83,10 @@ class Deploy extends core_1.Command {
         console.log(`CID saved at ${log_1.default.highlightText(fullOutputDir)}`);
         console.log(`Task deployed!`);
     }
-    async uploadToRegistry(files, key) {
+    async uploadToRegistry(files, key, registryUrl) {
         try {
             const form = filesToForm(files);
-            const { data } = await axios_1.default.post(`${MIMIC_REGISTRY}/tasks`, form, {
+            const { data } = await axios_1.default.post(`${registryUrl}/tasks`, form, {
                 headers: {
                     'x-api-key': key,
                     'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`,
@@ -110,6 +119,8 @@ Deploy.flags = {
     key: core_1.Flags.string({ char: 'k', description: 'Your account deployment key', required: true }),
     input: core_1.Flags.string({ char: 'i', description: 'Directory containing the compiled artifacts', default: './build' }),
     output: core_1.Flags.string({ char: 'o', description: 'Output directory for deployment CID', default: './build' }),
+    url: core_1.Flags.string({ char: 'u', description: `Mimic Registry base URL`, default: MIMIC_REGISTRY_DEFAULT }),
+    'skip-compile': core_1.Flags.boolean({ description: 'Skip codegen and compile steps before uploading', default: false }),
 };
 exports.default = Deploy;
 const filesToForm = (files) => {

package/dist/commands/init.js

@@ -48,19 +48,20 @@ class Init extends core_1.Command {
         const { directory, force } = flags;
         const fullDirectory = path.resolve(directory);
         const templateDirectory = path.join(__dirname, '../templates');
-        if (force) {
-            const shouldDelete = await (0, prompts_1.confirm)({
-                message: `Are you sure you want to ${log_1.default.warnText('delete')} all the contents in ${log_1.default.highlightText(fullDirectory)}. This action is ${log_1.default.warnText('irreversible')}`,
-                default: false,
-            });
+        if (force && fs.existsSync(fullDirectory) && fs.readdirSync(fullDirectory).length > 0) {
+            const shouldDelete = process.env.NODE_ENV === 'test'
+                ? true
+                : await (0, prompts_1.confirm)({
+                    message: `Are you sure you want to ${log_1.default.warnText('delete')} all the contents in ${log_1.default.highlightText(fullDirectory)}. This action is ${log_1.default.warnText('irreversible')}`,
+                    default: false,
+                });
             if (!shouldDelete) {
                 console.log('You can remove the --force flag from your command');
                 console.log('Stopping initialization...');
                 this.exit(0);
             }
             log_1.default.startAction(`Deleting contents of ${fullDirectory}`);
-            if (fs.existsSync(fullDirectory))
-                fs.rmSync(fullDirectory, { recursive: true });
+            fs.rmSync(fullDirectory, { recursive: true });
         }
         log_1.default.startAction('Creating files');
         if (fs.existsSync(fullDirectory) && fs.readdirSync(fullDirectory).length > 0) {

package/dist/lib/AbisInterfaceGenerator/ContractClassGenerator.js

@@ -5,37 +5,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("../../types");
 const AbiTypeConverter_1 = __importDefault(require("./AbiTypeConverter"));
+const EventHandler_1 = __importDefault(require("./EventHandler"));
 const FunctionHandler_1 = __importDefault(require("./FunctionHandler"));
 const ImportManager_1 = __importDefault(require("./ImportManager"));
 const NameManager_1 = __importDefault(require("./NameManager"));
 const TupleHandler_1 = __importDefault(require("./TupleHandler"));
+const UtilsHandler_1 = __importDefault(require("./UtilsHandler"));
 class ContractClassGenerator {
     constructor(abi) {
         this.abi = abi;
         this.importManager = new ImportManager_1.default();
         this.tupleDefinitions = TupleHandler_1.default.extractTupleDefinitions(this.abi);
+        this.eventDefinitions = EventHandler_1.default.extractEventDefinitions(this.abi);
         this.abiTypeConverter = new AbiTypeConverter_1.default(this.importManager, this.tupleDefinitions);
     }
     generate(contractName) {
-        const mainClassCode = this.generateMainClass(contractName);
+        const functions = NameManager_1.default.resolveMethodNames(this.getFunctions());
+        const mainClassCode = this.generateMainClass(contractName, functions);
+        const utilsClassCode = this.generateUtilsClass(contractName, functions);
         const tupleClassesCode = TupleHandler_1.default.generateTupleClassesCode(this.tupleDefinitions, this.importManager, this.abiTypeConverter);
+        const eventClassesCode = EventHandler_1.default.generateEventClassesCode(this.eventDefinitions, this.importManager, this.abiTypeConverter);
         // Note: this should be generated after any other generation
         const importsCode = this.importManager.generateImportsCode();
+        const ignoreLint = '/* eslint-disable @typescript-eslint/no-unused-vars */';
         const notice = '// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE MANUALLY.';
         const separator = '\n\n';
-        let result = notice + separator + importsCode + separator + mainClassCode;
+        let result = ignoreLint + separator + notice + separator + importsCode;
+        result += separator + mainClassCode;
+        result += separator + utilsClassCode;
         if (tupleClassesCode)
             result += separator + tupleClassesCode;
+        if (eventClassesCode)
+            result += separator + eventClassesCode;
         return result.trim();
     }
-    generateMainClass(contractName) {
+    generateMainClass(contractName, functions) {
         const lines = [];
         this.appendClassDefinition(lines, contractName);
-        const functions = NameManager_1.default.resolveMethodNames(this.getFunctions());
-        functions.forEach((fn) => FunctionHandler_1.default.appendMethod(lines, fn, this.importManager, this.tupleDefinitions, this.abiTypeConverter));
+        functions.forEach((fn) => FunctionHandler_1.default.appendMethod(lines, fn, this.importManager, this.tupleDefinitions, this.abiTypeConverter, contractName));
         lines.push('}');
         return lines.join('\n');
     }
+    generateUtilsClass(contractName, functions) {
+        return UtilsHandler_1.default.generate(contractName, functions, this.importManager, this.tupleDefinitions, this.abiTypeConverter);
+    }
     appendClassDefinition(lines, contractName) {
         this.importManager.addType(types_1.LibTypes.Address);
         this.importManager.addType(types_1.LibTypes.ChainId);

package/dist/lib/AbisInterfaceGenerator/EventHandler.js

@@ -0,0 +1,138 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../types");
+const NameManager_1 = __importStar(require("./NameManager"));
+const TupleHandler_1 = __importDefault(require("./TupleHandler"));
+class EventHandler {
+    static extractEventDefinitions(abi) {
+        const eventDefinitions = new Map();
+        abi.forEach((item) => {
+            if (item.type !== 'event')
+                return;
+            const components = NameManager_1.default.resolveParameterNames(item.inputs || [], NameManager_1.NameContext.CLASS_PROPERTY);
+            const componentsWithIndexed = components.map((comp, index) => ({
+                ...comp,
+                indexed: item.inputs?.[index]?.indexed || false,
+            }));
+            eventDefinitions.set(item.name, {
+                className: `${item.name}Event`,
+                components: componentsWithIndexed,
+            });
+        });
+        return eventDefinitions;
+    }
+    static generateEventClassesCode(eventDefinitions, importManager, abiTypeConverter) {
+        if (eventDefinitions.size === 0)
+            return '';
+        const lines = [];
+        eventDefinitions.forEach((def) => {
+            lines.push(`export class ${def.className} {`);
+            const components = def.components;
+            components.forEach((comp) => {
+                const fieldName = comp.escapedName;
+                const componentType = abiTypeConverter.mapAbiType(comp);
+                lines.push(`  readonly ${fieldName}: ${componentType}`);
+            });
+            lines.push('');
+            const constructorParams = components
+                .map((comp) => `${comp.escapedName}: ${abiTypeConverter.mapAbiType(comp)}`)
+                .join(', ');
+            lines.push(`  constructor(${constructorParams}) {`);
+            components.forEach((comp) => {
+                const fieldName = comp.escapedName;
+                lines.push(`    this.${fieldName} = ${fieldName}`);
+            });
+            lines.push(`  }`);
+            lines.push('');
+            const indexedParams = def.components.filter((c) => c.indexed);
+            const nonIndexedParams = def.components.filter((c) => !c.indexed);
+            importManager.addType('evm');
+            importManager.addType('EvmDecodeParam');
+            const topicsParam = indexedParams.length > 0 ? 'topics' : '_topics';
+            const dataParam = nonIndexedParams.length > 0 ? 'data' : '_data';
+            lines.push(`  static decode(${topicsParam}: ${types_1.AssemblyPrimitiveTypes.string}[], ${dataParam}: ${types_1.AssemblyPrimitiveTypes.string}): ${def.className} {`);
+            const localVarMap = new Map();
+            // Decode indexed parameters from topics
+            if (indexedParams.length > 0) {
+                lines.push(`    // Decode indexed parameters from topics`);
+                NameManager_1.default.resolveParameterNames(indexedParams, NameManager_1.NameContext.LOCAL_VARIABLE).forEach((param, index) => {
+                    const varName = param.escapedName;
+                    localVarMap.set(indexedParams[index].escapedName, varName);
+                    const mappedType = abiTypeConverter.mapAbiType(param);
+                    const rawValue = `evm.decode(new EvmDecodeParam('${param.type}', topics[${index + 1}]))`; // Skip topics[0] which is event signature
+                    lines.push(`    const ${varName}: ${mappedType} = ${abiTypeConverter.generateTypeConversion(mappedType, rawValue, false, false)}`);
+                });
+            }
+            // Decode non-indexed parameters from data
+            if (nonIndexedParams.length > 0) {
+                lines.push(`    // Decode non-indexed parameters from data`);
+                const dataAbiType = nonIndexedParams.length === 1
+                    ? nonIndexedParams[0].type
+                    : TupleHandler_1.default.generateTupleTypeString('tuple', nonIndexedParams.map((c) => ({ type: c.type, components: c.components })));
+                lines.push(`    const decodedData = evm.decode(new EvmDecodeParam('${dataAbiType}', data))`);
+                const nonIndexedWithVarNames = NameManager_1.default.resolveParameterNames(nonIndexedParams, NameManager_1.NameContext.LOCAL_VARIABLE);
+                if (nonIndexedParams.length === 1) {
+                    const param = nonIndexedWithVarNames[0];
+                    const varName = param.escapedName;
+                    localVarMap.set(nonIndexedParams[0].escapedName, varName);
+                    const mappedType = abiTypeConverter.mapAbiType(param);
+                    lines.push(`    const ${varName}: ${mappedType} = ${abiTypeConverter.generateTypeConversion(mappedType, 'decodedData', false, false)}`);
+                }
+                else {
+                    importManager.addType('JSON');
+                    lines.push(`    const dataParts = JSON.parse<${types_1.AssemblyPrimitiveTypes.string}[]>(decodedData)`);
+                    nonIndexedWithVarNames.forEach((param, index) => {
+                        const varName = param.escapedName;
+                        localVarMap.set(nonIndexedParams[index].escapedName, varName);
+                        const mappedType = abiTypeConverter.mapAbiType(param);
+                        const parseLogic = TupleHandler_1.default.buildFieldParseLogic(`dataParts[${index}]`, param, mappedType, abiTypeConverter, importManager);
+                        lines.push(`    const ${varName}: ${mappedType} = ${parseLogic}`);
+                    });
+                }
+            }
+            const constructorArgs = def.components.map((c) => localVarMap.get(c.escapedName) || c.escapedName).join(', ');
+            lines.push(`    return new ${def.className}(${constructorArgs})`);
+            lines.push(`  }`);
+            lines.push(`}`);
+            lines.push('');
+        });
+        return lines.join('\n');
+    }
+}
+exports.default = EventHandler;

package/dist/lib/AbisInterfaceGenerator/FunctionHandler.js

@@ -36,23 +36,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_1 = require("../../helpers");
 const types_1 = require("../../types");
-const ArrayHandler_1 = __importDefault(require("./ArrayHandler"));
 const NameManager_1 = __importStar(require("./NameManager"));
 const TupleHandler_1 = __importDefault(require("./TupleHandler"));
 const types_2 = require("./types");
 class FunctionHandler {
-    static appendMethod(lines, fn, importManager, tupleDefinitions, abiTypeConverter) {
-        const inputs = NameManager_1.default.resolveParameterNames(fn.inputs || [], NameManager_1.NameContext.FUNCTION_PARAMETER, 'param');
-        const methodParams = this.generateMethodParams(inputs, abiTypeConverter);
-        const returnType = this.getReturnType(fn, tupleDefinitions, abiTypeConverter);
-        const methodName = fn.escapedName || fn.name;
-        lines.push(`  ${methodName}(${methodParams}): ${returnType} {`);
-        const callArgs = this.generateCallArguments(inputs, importManager, abiTypeConverter);
-        this.appendFunctionBody(lines, fn, returnType, callArgs, importManager, abiTypeConverter);
-        lines.push(`  }`);
-        lines.push('');
+    static appendMethod(lines, fn, importManager, tupleDefinitions, abiTypeConverter, contractName) {
+        if (this.isWriteFunction(fn)) {
+            this.appendWriteMethod(lines, fn, importManager, tupleDefinitions, abiTypeConverter, contractName);
+            return;
+        }
+        this.appendReadMethod(lines, fn, importManager, tupleDefinitions, abiTypeConverter, contractName);
+    }
+    static getCapitalizedName(fn) {
+        const baseName = fn.escapedName || fn.name;
+        return `${baseName.charAt(0).toUpperCase()}${baseName.slice(1)}`;
+    }
+    static isWriteFunction(fn) {
+        return ['nonpayable', 'payable'].includes(fn.stateMutability || '');
     }
     static getReturnType(fn, tupleDefinitions, abiTypeConverter) {
         if (this.isWriteFunction(fn))
@@ -83,91 +84,39 @@ class FunctionHandler {
         })
             .join(', ');
     }
-    static buildEvmEncodeParamCode(valueIdentifier, paramDefinition, abiTypeConverter, importManager, depth = 0) {
-        importManager.addType('EvmEncodeParam');
-        const currentAbiTypeSignature = TupleHandler_1.default.isBaseTypeATuple(paramDefinition.type)
-            ? TupleHandler_1.default.mapTupleType(paramDefinition.type)
-            : paramDefinition.type;
-        if (ArrayHandler_1.default.isArrayType(paramDefinition.type)) {
-            const elementLambdaVar = `s${depth}`;
-            const elementAbiDefinition = {
-                name: elementLambdaVar,
-                type: ArrayHandler_1.default.getArrayType(paramDefinition.type),
-                components: TupleHandler_1.default.isBaseTypeATuple(ArrayHandler_1.default.getArrayType(paramDefinition.type))
-                    ? paramDefinition.components
-                    : undefined,
-                internalType: paramDefinition.internalType
-                    ? ArrayHandler_1.default.getArrayType(paramDefinition.internalType)
-                    : undefined,
-            };
-            const nestedEvmParam = FunctionHandler.buildEvmEncodeParamCode(elementLambdaVar, elementAbiDefinition, abiTypeConverter, importManager, depth + 1);
-            return `EvmEncodeParam.fromValues('${currentAbiTypeSignature}', ${valueIdentifier}.map<EvmEncodeParam>((${elementLambdaVar}) => ${nestedEvmParam}))`;
-        }
-        if (TupleHandler_1.default.isBaseTypeATuple(paramDefinition.type)) {
-            return `EvmEncodeParam.fromValues('${currentAbiTypeSignature}', ${valueIdentifier}.toEvmEncodeParams())`;
-        }
-        const mappedParamType = abiTypeConverter.mapAbiType(paramDefinition);
-        const convertedValue = abiTypeConverter.toLibType(mappedParamType, valueIdentifier);
-        return `EvmEncodeParam.fromValue('${currentAbiTypeSignature}', ${convertedValue})`;
-    }
-    static generateCallArguments(inputs, importManager, abiTypeConverter) {
-        return inputs
-            .map((input) => {
-            const paramName = input.escapedName;
-            return FunctionHandler.buildEvmEncodeParamCode(paramName, input, abiTypeConverter, importManager, 0);
-        })
-            .join(', ');
-    }
-    static getDecodeAbiType(fn) {
-        const outputs = fn.outputs ?? [];
-        if (outputs.length === 0)
-            return '()';
-        if (outputs.length === 1) {
-            const [output] = outputs;
-            const { type, components } = output;
-            if (TupleHandler_1.default.isBaseTypeATuple(type) && components)
-                return TupleHandler_1.default.generateTupleTypeString(type, components);
-            return type;
-        }
-        return TupleHandler_1.default.generateTupleTypeString(types_2.TUPLE_ABI_TYPE, outputs);
-    }
-    static getReturnExpression(currentType, dataAccessString, importManager, abiTypeConverter, depth = 0) {
-        if (ArrayHandler_1.default.isArrayType(currentType)) {
-            importManager.addType('JSON');
-            const elementType = ArrayHandler_1.default.getArrayType(currentType);
-            const itemVar = `item${depth}`;
-            const subLogic = this.getReturnExpression(elementType, itemVar, importManager, abiTypeConverter, depth + 1);
-            return `${dataAccessString} === '' ? [] : JSON.parse<${types_1.AssemblyPrimitiveTypes.string}[]>(${dataAccessString}).map<${elementType}>(((${itemVar}: ${types_1.AssemblyPrimitiveTypes.string}) => ${subLogic}))`;
-        }
-        return abiTypeConverter.generateTypeConversion(currentType, dataAccessString, false, false);
+    static appendWriteMethod(lines, fn, importManager, tupleDefinitions, abiTypeConverter, contractName) {
+        const inputs = NameManager_1.default.resolveParameterNames(fn.inputs || [], NameManager_1.NameContext.FUNCTION_PARAMETER, 'param');
+        const methodParams = this.generateMethodParams(inputs, abiTypeConverter);
+        const returnType = this.getReturnType(fn, tupleDefinitions, abiTypeConverter);
+        const methodName = fn.escapedName || fn.name;
+        const capitalizedName = this.getCapitalizedName(fn);
+        lines.push(`  ${methodName}(${methodParams}): ${returnType} {`);
+        lines.push(`    const encodedData = ${contractName}Utils.encode${capitalizedName}(${inputs.map((p) => p.escapedName).join(', ')})`);
+        importManager.addType(types_1.LibTypes.Bytes);
+        importManager.addType('CallBuilder');
+        lines.push(`    return CallBuilder.forChain(this._chainId).addCall(this._address, encodedData)`);
+        lines.push(`  }`);
+        lines.push('');
     }
-    static appendFunctionBody(lines, fn, returnType, callArgs, importManager, abiTypeConverter) {
-        const selector = (0, helpers_1.getFunctionSelector)(fn);
-        if (callArgs)
-            importManager.addType('evm');
-        const encodedCall = `'${selector}'${callArgs ? ` + evm.encode([${callArgs}])` : ''}`;
-        if (this.isWriteFunction(fn)) {
-            importManager.addType(types_1.LibTypes.Bytes);
-            importManager.addType('CallBuilder');
-            lines.push(`    const encodedData = Bytes.fromHexString(${encodedCall})`);
-            lines.push(`    return CallBuilder.forChain(this._chainId).addCall(this._address, encodedData)`);
-            return;
-        }
+    static appendReadMethod(lines, fn, importManager, tupleDefinitions, abiTypeConverter, contractName) {
+        const inputs = NameManager_1.default.resolveParameterNames(fn.inputs || [], NameManager_1.NameContext.FUNCTION_PARAMETER, 'param');
+        const methodParams = this.generateMethodParams(inputs, abiTypeConverter);
+        const returnType = this.getReturnType(fn, tupleDefinitions, abiTypeConverter);
+        const methodName = fn.escapedName || fn.name;
+        const capitalizedName = this.getCapitalizedName(fn);
+        lines.push(`  ${methodName}(${methodParams}): ${returnType} {`);
+        lines.push(`    const encodedData = ${contractName}Utils.encode${capitalizedName}(${inputs.map((p) => p.escapedName).join(', ')})`);
         importManager.addType('environment');
-        const contractCallCode = `environment.contractCall(this._address, this._chainId, this._timestamp, ${encodedCall})`;
+        const contractCallLine = `environment.contractCall(this._address, this._chainId, this._timestamp, encodedData.toHexString())`;
         if (returnType === 'void') {
-            lines.push(`    ${contractCallCode}`);
-            return;
+            lines.push(`    ${contractCallLine}`);
         }
-        importManager.addType('EvmDecodeParam');
-        const decodeAbiType = this.getDecodeAbiType(fn);
-        lines.push(`    const response = ${contractCallCode}`);
-        lines.push(`    const decodedResponse = evm.decode(new EvmDecodeParam('${decodeAbiType}', response))`);
-        const returnExpression = this.getReturnExpression(returnType, 'decodedResponse', importManager, abiTypeConverter);
-        lines.push(`    return ${returnExpression}`);
-    }
-    static isWriteFunction(fn) {
-        return ['nonpayable', 'payable'].includes(fn.stateMutability || '');
+        else {
+            lines.push(`    const response = ${contractCallLine}`);
+            lines.push(`    return ${contractName}Utils.decode${capitalizedName}(response)`);
+        }
+        lines.push(`  }`);
+        lines.push('');
     }
 }
 exports.default = FunctionHandler;

package/dist/lib/AbisInterfaceGenerator/TupleHandler.js

@@ -39,9 +39,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const helpers_1 = require("../../helpers");
 const types_1 = require("../../types");
 const ArrayHandler_1 = __importDefault(require("./ArrayHandler"));
-const FunctionHandler_1 = __importDefault(require("./FunctionHandler"));
 const NameManager_1 = __importStar(require("./NameManager"));
 const types_2 = require("./types");
+const UtilsHandler_1 = __importDefault(require("./UtilsHandler"));
 class TupleHandler {
     /**
      * Checks if the given ABI type string ultimately represents a tuple.
@@ -206,15 +206,6 @@ class TupleHandler {
             return 'UnnamedFunctionOutputs';
         return `${(0, helpers_1.pascalCase)(fnNamePart)}Outputs`;
     }
-    static getTupleParseMethodBody(def, abiTypeConverter, importManager) {
-        return def.components.map((comp, index) => {
-            const fieldName = comp.escapedName;
-            const mappedComponentType = abiTypeConverter.mapAbiType(comp);
-            const dataAccess = `parts[${index}]`;
-            const parseLogic = this.buildFieldParseLogic(dataAccess, comp, mappedComponentType, abiTypeConverter, importManager);
-            return `    const ${fieldName}: ${mappedComponentType} = ${parseLogic};`;
-        });
-    }
     static buildFieldParseLogic(dataAccessString, componentAbiParam, mappedTargetType, abiTypeConverter, importManager, depth = 0) {
         importManager.addType('JSON');
         const isAbiArray = ArrayHandler_1.default.isArrayType(componentAbiParam.type);
@@ -236,11 +227,20 @@ class TupleHandler {
         }
         return abiTypeConverter.generateTypeConversion(mappedTargetType, dataAccessString, false, false);
     }
+    static getTupleParseMethodBody(def, abiTypeConverter, importManager) {
+        return def.components.map((comp, index) => {
+            const fieldName = comp.escapedName;
+            const mappedComponentType = abiTypeConverter.mapAbiType(comp);
+            const dataAccess = `parts[${index}]`;
+            const parseLogic = this.buildFieldParseLogic(dataAccess, comp, mappedComponentType, abiTypeConverter, importManager);
+            return `    const ${fieldName}: ${mappedComponentType} = ${parseLogic};`;
+        });
+    }
     static getTupleToEvmParamsMethodBody(def, abiTypeConverter, importManager) {
         return def.components.map((comp) => {
             const fieldName = comp.escapedName;
             const valueAccessPath = `this.${fieldName}`;
-            const paramCode = FunctionHandler_1.default.buildEvmEncodeParamCode(valueAccessPath, comp, abiTypeConverter, importManager);
+            const paramCode = UtilsHandler_1.default.buildEvmEncodeParamCode(valueAccessPath, comp, abiTypeConverter, importManager);
             return `      ${paramCode},`;
         });
     }

package/dist/lib/AbisInterfaceGenerator/UtilsHandler.js

@@ -0,0 +1,150 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+const ArrayHandler_1 = __importDefault(require("./ArrayHandler"));
+const FunctionHandler_1 = __importDefault(require("./FunctionHandler"));
+const NameManager_1 = __importStar(require("./NameManager"));
+const TupleHandler_1 = __importDefault(require("./TupleHandler"));
+const types_2 = require("./types");
+class UtilsHandler {
+    static generate(contractName, functions, importManager, tupleDefinitions, abiTypeConverter) {
+        const methods = [];
+        functions.forEach((fn) => {
+            methods.push(this.generateEncodeMethod(fn, importManager, abiTypeConverter));
+            methods.push(this.generateDecodeMethod(fn, importManager, tupleDefinitions, abiTypeConverter));
+        });
+        const nonEmptyMethods = methods.filter((method) => method.trim() !== '');
+        return `export class ${contractName}Utils {\n${nonEmptyMethods.join('\n')}\n}`;
+    }
+    static buildEvmEncodeParamCode(valueIdentifier, paramDefinition, abiTypeConverter, importManager, depth = 0) {
+        importManager.addType('EvmEncodeParam');
+        const currentAbiTypeSignature = TupleHandler_1.default.isBaseTypeATuple(paramDefinition.type)
+            ? TupleHandler_1.default.mapTupleType(paramDefinition.type)
+            : paramDefinition.type;
+        if (ArrayHandler_1.default.isArrayType(paramDefinition.type)) {
+            const elementLambdaVar = `s${depth}`;
+            const elementAbiDefinition = {
+                name: elementLambdaVar,
+                type: ArrayHandler_1.default.getArrayType(paramDefinition.type),
+                components: TupleHandler_1.default.isBaseTypeATuple(ArrayHandler_1.default.getArrayType(paramDefinition.type))
+                    ? paramDefinition.components
+                    : undefined,
+                internalType: paramDefinition.internalType
+                    ? ArrayHandler_1.default.getArrayType(paramDefinition.internalType)
+                    : undefined,
+            };
+            const nestedEvmParam = UtilsHandler.buildEvmEncodeParamCode(elementLambdaVar, elementAbiDefinition, abiTypeConverter, importManager, depth + 1);
+            return `EvmEncodeParam.fromValues('${currentAbiTypeSignature}', ${valueIdentifier}.map<EvmEncodeParam>((${elementLambdaVar}) => ${nestedEvmParam}))`;
+        }
+        if (TupleHandler_1.default.isBaseTypeATuple(paramDefinition.type)) {
+            return `EvmEncodeParam.fromValues('${currentAbiTypeSignature}', ${valueIdentifier}.toEvmEncodeParams())`;
+        }
+        const mappedParamType = abiTypeConverter.mapAbiType(paramDefinition);
+        const convertedValue = abiTypeConverter.toLibType(mappedParamType, valueIdentifier);
+        return `EvmEncodeParam.fromValue('${currentAbiTypeSignature}', ${convertedValue})`;
+    }
+    static generateEncodeMethod(fn, importManager, abiTypeConverter) {
+        const inputs = NameManager_1.default.resolveParameterNames(fn.inputs || [], NameManager_1.NameContext.FUNCTION_PARAMETER, 'param');
+        const methodParams = FunctionHandler_1.default.generateMethodParams(inputs, abiTypeConverter);
+        const capitalizedName = FunctionHandler_1.default.getCapitalizedName(fn);
+        importManager.addType(types_1.LibTypes.Bytes);
+        const lines = [];
+        lines.push(`  static encode${capitalizedName}(${methodParams}): Bytes {`);
+        const callArgs = this.generateCallArguments(inputs, importManager, abiTypeConverter);
+        const selector = (0, helpers_1.getFunctionSelector)(fn);
+        if (callArgs)
+            importManager.addType('evm');
+        const encodedCall = `'${selector}'${callArgs ? ` + evm.encode([${callArgs}])` : ''}`;
+        lines.push(`    return Bytes.fromHexString(${encodedCall})`);
+        lines.push(`  }`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    static generateDecodeMethod(fn, importManager, tupleDefinitions, abiTypeConverter) {
+        const capitalizedName = FunctionHandler_1.default.getCapitalizedName(fn);
+        // Skip decode method for write functions or void returns
+        const returnType = FunctionHandler_1.default.getReturnType(fn, tupleDefinitions, abiTypeConverter);
+        if (FunctionHandler_1.default.isWriteFunction(fn) || returnType === 'void')
+            return '';
+        importManager.addType('EvmDecodeParam');
+        importManager.addType('evm');
+        const lines = [];
+        lines.push(`  static decode${capitalizedName}(encodedResponse: string): ${returnType} {`);
+        const decodeAbiType = this.getDecodeAbiType(fn);
+        lines.push(`    const decodedResponse = evm.decode(new EvmDecodeParam('${decodeAbiType}', encodedResponse))`);
+        const returnExpression = this.getReturnExpression(returnType, 'decodedResponse', importManager, abiTypeConverter);
+        lines.push(`    return ${returnExpression}`);
+        lines.push(`  }`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    static generateCallArguments(inputs, importManager, abiTypeConverter) {
+        return inputs
+            .map((input) => {
+            const paramName = input.escapedName;
+            return UtilsHandler.buildEvmEncodeParamCode(paramName, input, abiTypeConverter, importManager, 0);
+        })
+            .join(', ');
+    }
+    static getDecodeAbiType(fn) {
+        const outputs = fn.outputs ?? [];
+        if (outputs.length === 0)
+            return '()';
+        if (outputs.length === 1) {
+            const [output] = outputs;
+            const { type, components } = output;
+            if (TupleHandler_1.default.isBaseTypeATuple(type) && components)
+                return TupleHandler_1.default.generateTupleTypeString(type, components);
+            return type;
+        }
+        return TupleHandler_1.default.generateTupleTypeString(types_2.TUPLE_ABI_TYPE, outputs);
+    }
+    static getReturnExpression(currentType, dataAccessString, importManager, abiTypeConverter, depth = 0) {
+        if (ArrayHandler_1.default.isArrayType(currentType)) {
+            importManager.addType('JSON');
+            const elementType = ArrayHandler_1.default.getArrayType(currentType);
+            const itemVar = `item${depth}`;
+            const subLogic = this.getReturnExpression(elementType, itemVar, importManager, abiTypeConverter, depth + 1);
+            return `${dataAccessString} === '' ? [] : JSON.parse<${types_1.AssemblyPrimitiveTypes.string}[]>(${dataAccessString}).map<${elementType}>(((${itemVar}: ${types_1.AssemblyPrimitiveTypes.string}) => ${subLogic}))`;
+        }
+        return abiTypeConverter.generateTypeConversion(currentType, dataAccessString, false, false);
+    }
+}
+exports.default = UtilsHandler;

package/dist/templates/manifest.yaml

@@ -6,4 +6,4 @@ inputs:
   - token: address
   - amount: uint256
   - recipient: address
-  - fee: uint256
+  - maxFee: uint256

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimicprotocol/cli",
-  "version": "0.0.1-rc.18",
+  "version": "0.0.1-rc.19",
   "license": "GPL-3.0",
   "private": false,
   "type": "commonjs",