@mimicprotocol/cli 0.0.1-rc.9

package/dist/lib/AbisInterfaceGenerator/TupleHandler.js

@@ -0,0 +1,250 @@
+"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 ArrayHandler_1 = __importDefault(require("./ArrayHandler"));
+const FunctionHandler_1 = __importDefault(require("./FunctionHandler"));
+const NameManager_1 = __importStar(require("./NameManager"));
+const types_1 = require("./types");
+class TupleHandler {
+    /**
+     * Checks if the given ABI type string ultimately represents a tuple.
+     * E.g., 'tuple', 'tuple[]', 'tuple[2]' would all return true.
+     */
+    static isBaseTypeATuple(abiType) {
+        return ArrayHandler_1.default.getBaseType(abiType) === types_1.TUPLE_ABI_TYPE;
+    }
+    /**
+     * Checks if the given value is a tuple class name.
+     */
+    static isTupleClassName(value, tupleDefinitions) {
+        return [...tupleDefinitions.values()].some((def) => def.className === value);
+    }
+    /**
+     * Gets the class name for an already defined tuple.
+     * Uses internalType or structural matching if necessary.
+     */
+    static getClassNameForTupleDefinition(param, tupleDefinitions) {
+        if (!this.isBaseTypeATuple(param.type))
+            return undefined;
+        const baseInternalType = param.internalType ? ArrayHandler_1.default.getBaseType(param.internalType) : undefined;
+        if (baseInternalType && tupleDefinitions.has(baseInternalType))
+            return tupleDefinitions.get(baseInternalType).className;
+        const representativeParamForSearch = {
+            ...param,
+            type: types_1.TUPLE_ABI_TYPE,
+        };
+        const existingByStructure = this.findMatchingDefinition(representativeParamForSearch, tupleDefinitions);
+        if (existingByStructure)
+            return existingByStructure.className;
+        return undefined;
+    }
+    static extractTupleDefinitions(abi) {
+        const tupleDefinitions = new Map();
+        let tupleCounter = 0;
+        const processParam = (param) => {
+            if (!this.isBaseTypeATuple(param.type)) {
+                param.components?.forEach(processParam);
+                return;
+            }
+            const tupleToDefine = {
+                name: param.name,
+                type: types_1.TUPLE_ABI_TYPE,
+                internalType: param.internalType,
+                components: param.components,
+            };
+            if (!tupleToDefine.components || tupleToDefine.components.length === 0)
+                return;
+            const existingClassName = this.getClassNameForTupleDefinition(tupleToDefine, tupleDefinitions);
+            if (existingClassName)
+                return existingClassName;
+            let className = `Tuple${tupleCounter++}`;
+            const baseInternalType = tupleToDefine.internalType
+                ? ArrayHandler_1.default.getBaseType(tupleToDefine.internalType)
+                : undefined;
+            if (baseInternalType) {
+                const structMatch = baseInternalType.match(/struct\s+(?:\w+\.)?(\w+)/);
+                if (structMatch && structMatch[1])
+                    className = structMatch[1];
+            }
+            const key = baseInternalType || className;
+            const components = this.resolveComponentNames(tupleToDefine.components, NameManager_1.NameContext.CLASS_PROPERTY);
+            tupleDefinitions.set(key, {
+                className,
+                components,
+            });
+            tupleToDefine.components.forEach((subComp) => processParam(subComp));
+            return className;
+        };
+        abi.forEach((item) => {
+            if (item.type !== 'function')
+                return;
+            item.inputs?.forEach((input) => processParam(input));
+            item.outputs?.forEach((output) => processParam(output));
+            if (item.outputs && item.outputs.length > 1) {
+                const name = this.getOutputTupleClassName(item.name);
+                const representativeOutputTuple = {
+                    name,
+                    type: types_1.TUPLE_ABI_TYPE,
+                    internalType: `struct ${name}`,
+                    components: item.outputs,
+                };
+                processParam(representativeOutputTuple);
+            }
+        });
+        return tupleDefinitions;
+    }
+    static findMatchingDefinition(param, definitions) {
+        if (!param.components || param.type !== types_1.TUPLE_ABI_TYPE)
+            return undefined;
+        return [...definitions.values()].find((def) => def.components.length === param.components.length &&
+            def.components.every((c, i) => c.type === param.components[i].type &&
+                (c.name === param.components[i].name || !c.name || !param.components[i].name)));
+    }
+    static generateTupleTypeString(type, components) {
+        if (!components || components.length === 0)
+            return this.mapTupleType(type);
+        const typeStrings = components.map((comp) => {
+            if (this.isBaseTypeATuple(comp.type) && comp.components)
+                return this.generateTupleTypeString(comp.type, comp.components);
+            return comp.type;
+        });
+        return this.mapTupleType(type, typeStrings.join(','));
+    }
+    static mapTupleType(abiType, tupleContent = '') {
+        if (!this.isBaseTypeATuple(abiType))
+            throw new Error(`${abiType} is not a tuple type`);
+        return abiType.replace(types_1.TUPLE_ABI_TYPE, `(${tupleContent})`);
+    }
+    static generateTupleClassesCode(tupleDefinitions, importManager, abiTypeConverter) {
+        if (tupleDefinitions.size === 0)
+            return '';
+        importManager.addType('parseCSVNotNullable');
+        const lines = [];
+        tupleDefinitions.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) => {
+                const fieldName = comp.escapedName;
+                const componentType = abiTypeConverter.mapAbiType(comp);
+                return `${fieldName}: ${componentType}`;
+            })
+                .join(', ');
+            lines.push(`  constructor(${constructorParams}) {`);
+            components.forEach((comp) => {
+                const fieldName = comp.escapedName;
+                lines.push(`    this.${fieldName} = ${fieldName}`);
+            });
+            lines.push(`  }`);
+            lines.push('');
+            lines.push(`  static parse(data: string): ${def.className} {`);
+            lines.push(`    const parts = parseCSVNotNullable(data)`);
+            lines.push(`    if (parts.length !== ${def.components.length}) throw new Error("Invalid data for tuple parsing")`);
+            const componentsWithVarNames = this.resolveComponentNames(def.components, NameManager_1.NameContext.LOCAL_VARIABLE);
+            lines.push(...this.getTupleParseMethodBody({ ...def, components: componentsWithVarNames }, abiTypeConverter, importManager));
+            const constructorArgs = componentsWithVarNames.map((r) => r.escapedName).join(', ');
+            lines.push(`    return new ${def.className}(${constructorArgs})`);
+            lines.push(`  }`);
+            lines.push('');
+            lines.push(`  toEvmEncodeParams(): EvmEncodeParam[] {`);
+            importManager.addType('EvmEncodeParam');
+            lines.push(`    return [`);
+            lines.push(...this.getTupleToEvmParamsMethodBody(def, abiTypeConverter, importManager));
+            lines.push(`    ]`);
+            lines.push(`  }`);
+            lines.push(`}`);
+            lines.push('');
+        });
+        return lines.join('\n');
+    }
+    static getOutputTupleClassName(functionName) {
+        const fnNamePart = functionName.replace(/[^a-zA-Z0-9_]/g, '');
+        if (!fnNamePart)
+            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('parseCSVNotNullable');
+        const isAbiArray = ArrayHandler_1.default.isArrayType(componentAbiParam.type);
+        const baseAbiType = ArrayHandler_1.default.getBaseType(componentAbiParam.type);
+        if (isAbiArray) {
+            const elementType = ArrayHandler_1.default.getArrayType(mappedTargetType);
+            const itemVar = `item${depth}`;
+            const elementAbiParam = {
+                ...componentAbiParam,
+                name: `${componentAbiParam.name || 'arrayElement'}_${itemVar}`,
+                type: ArrayHandler_1.default.getArrayType(componentAbiParam.type),
+                components: baseAbiType === types_1.TUPLE_ABI_TYPE ? componentAbiParam.components : undefined,
+                internalType: componentAbiParam.internalType
+                    ? ArrayHandler_1.default.getArrayType(componentAbiParam.internalType)
+                    : undefined,
+            };
+            const subLogic = this.buildFieldParseLogic(itemVar, elementAbiParam, elementType, abiTypeConverter, importManager, depth + 1);
+            return `${dataAccessString} === '' ? [] : parseCSVNotNullable(${dataAccessString}).map<${elementType}>(((${itemVar}: string) => ${subLogic}))`;
+        }
+        return abiTypeConverter.generateTypeConversion(mappedTargetType, dataAccessString, false, false);
+    }
+    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);
+            return `      ${paramCode},`;
+        });
+    }
+    static resolveComponentNames(components, context) {
+        return NameManager_1.default.resolveParameterNames(components, context, 'field');
+    }
+}
+exports.default = TupleHandler;

package/dist/lib/AbisInterfaceGenerator/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ContractClassGenerator_1 = __importDefault(require("./ContractClassGenerator"));
+exports.default = {
+    generate(abi, contractName) {
+        return new ContractClassGenerator_1.default(abi).generate(contractName);
+    },
+};

package/dist/lib/AbisInterfaceGenerator/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TUPLE_ABI_TYPE = void 0;
+exports.TUPLE_ABI_TYPE = 'tuple';

package/dist/lib/InputsInterfaceGenerator.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    generate(inputs) {
+        if (Object.entries(inputs).length == 0)
+            return '';
+        const convertedInputs = convertInputs(inputs);
+        const inputsMapping = generateInputsMapping(convertedInputs);
+        const imports = generateImports(convertedInputs);
+        const inputsClass = generateInputsClass(convertedInputs);
+        return [
+            '// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE MANUALLY.',
+            '',
+            imports,
+            '',
+            'declare namespace input {',
+            `  ${inputsMapping}`,
+            '}',
+            '',
+            '// The class name is intentionally lowercase and plural to resemble a namespace when used in a task.',
+            'export class inputs {',
+            `  ${inputsClass}`,
+            '}',
+        ]
+            .join('\n')
+            .trim();
+    },
+};
+function convertInputs(inputs) {
+    return Object.fromEntries(Object.entries(inputs).map(([name, type]) => [name, convertType(type)]));
+}
+function generateImports(inputs) {
+    const typesToImport = new Set(Object.values(inputs).filter((e) => e === 'Address' || e === 'Bytes' || e === 'BigInt'));
+    if (typesToImport.size === 0)
+        return '';
+    return `import { ${[...typesToImport].sort().join(', ')} } from '@mimicprotocol/lib-ts'`;
+}
+function generateInputsMapping(inputs) {
+    return Object.entries(inputs)
+        .map(([name, type]) => type === 'string' || type === 'Address' || type === 'Bytes' || type === 'BigInt'
+        ? `var ${name}: string | null`
+        : `const ${name}: ${type}`)
+        .join('\n  ');
+}
+function generateInputsClass(inputs) {
+    return Object.entries(inputs)
+        .map(([name, type]) => generateGetter(name, type))
+        .join('\n\n  ');
+}
+function convertType(type) {
+    const match = type.match(/^(u?)int(\d+)?$/);
+    if (match) {
+        const isUnsigned = match[1] === 'u';
+        const size = parseInt(match[2] || '256');
+        const prefix = isUnsigned ? 'u' : 'i';
+        if (size <= 8)
+            return `${prefix}8`;
+        if (size <= 16)
+            return `${prefix}16`;
+        if (size <= 32)
+            return `${prefix}32`;
+        if (size <= 64)
+            return `${prefix}64`;
+        return 'BigInt'; // 128 and 256 go here
+    }
+    if (type.includes('address'))
+        return 'Address';
+    if (type.includes('bytes'))
+        return 'Bytes';
+    return type;
+}
+function generateGetter(name, type) {
+    const str = `input.${name}`;
+    let returnStr;
+    if (type === 'string')
+        returnStr = `${str}!`;
+    else if (type === 'Address')
+        returnStr = `Address.fromString(${str}!)`;
+    else if (type === 'Bytes')
+        returnStr = `Bytes.fromHexString(${str}!)`;
+    else if (type === 'BigInt')
+        returnStr = `BigInt.fromString(${str}!)`;
+    else
+        returnStr = str;
+    return `static get ${name}(): ${type} {
+    return ${returnStr}
+  }`;
+}

package/dist/lib/ManifestHandler.js

@@ -0,0 +1,134 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const js_yaml_1 = require("js-yaml");
+const path = __importStar(require("path"));
+const zod_1 = require("zod");
+const errors_1 = require("../errors");
+const validators_1 = require("../validators");
+exports.default = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    validate(manifest) {
+        if (!manifest)
+            throw new errors_1.EmptyManifestError();
+        const mergedManifest = {
+            ...manifest,
+            inputs: mergeIfUnique(manifest.inputs),
+            abis: mergeIfUnique(manifest.abis),
+            metadata: { libVersion: getLibVersion() },
+        };
+        return validators_1.ManifestValidator.parse(mergedManifest);
+    },
+    load(command, manifestDir) {
+        let loadedManifest;
+        try {
+            loadedManifest = (0, js_yaml_1.load)(fs.readFileSync(manifestDir, 'utf-8'));
+        }
+        catch {
+            command.error(`Could not find ${manifestDir}`, {
+                code: 'FileNotFound',
+                suggestions: ['Use the -m or --manifest flag to specify the correct path'],
+            });
+        }
+        try {
+            return this.validate(loadedManifest);
+        }
+        catch (err) {
+            handleValidationError(command, err);
+        }
+    },
+};
+function mergeIfUnique(list) {
+    const merged = {};
+    for (const obj of list || []) {
+        const entries = Object.entries(obj);
+        if (entries.length !== 1)
+            throw new errors_1.MoreThanOneEntryError(entries);
+        const [key, val] = entries[0];
+        if (key in merged)
+            throw new errors_1.DuplicateEntryError(key);
+        merged[key] = val;
+    }
+    return merged;
+}
+function handleValidationError(command, err) {
+    let message;
+    let code;
+    let suggestions;
+    if (err instanceof errors_1.MoreThanOneEntryError) {
+        ;
+        [message, code] = [err.message, err.name];
+        suggestions = [`${err.location[1][0]}: ${err.location[1][1]} might be missing a prepended '-' on manifest`];
+    }
+    else if (err instanceof errors_1.DuplicateEntryError) {
+        ;
+        [message, code] = [err.message, err.name];
+        suggestions = [`Review manifest for duplicate key: ${err.duplicateKey}`];
+    }
+    else if (err instanceof errors_1.EmptyManifestError) {
+        ;
+        [message, code] = [err.message, err.name];
+        suggestions = ['Verify if you are using the correct manifest file'];
+    }
+    else if (err instanceof zod_1.ZodError) {
+        ;
+        [message, code] = ['Missing/Incorrect Fields', 'FieldsError'];
+        suggestions = err.errors.map((e) => `Fix Field "${e.path.join('.')}" -- ${e.message}`);
+    }
+    else {
+        ;
+        [message, code] = [`Unkown Error: ${err}`, 'UnknownError'];
+        suggestions = [
+            'Contact the Mimic team for further assistance at our website https://www.mimic.fi/ or discord https://discord.com/invite/cpcyV9EsEg',
+        ];
+    }
+    command.error(message, { code, suggestions });
+}
+function getLibVersion() {
+    try {
+        let currentDir = process.cwd();
+        while (currentDir !== path.dirname(currentDir)) {
+            const libPackagePath = path.join(currentDir, 'node_modules', '@mimicprotocol', 'lib-ts', 'package.json');
+            if (fs.existsSync(libPackagePath))
+                return JSON.parse(fs.readFileSync(libPackagePath, 'utf-8')).version;
+            currentDir = path.dirname(currentDir);
+        }
+        throw new Error('Could not find @mimicprotocol/lib-ts package');
+    }
+    catch (error) {
+        throw new Error(`Failed to read @mimicprotocol/lib-ts version: ${error}`);
+    }
+}

package/dist/lib/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestHandler = exports.InputsInterfaceGenerator = exports.AbisInterfaceGenerator = void 0;
+const index_1 = __importDefault(require("./AbisInterfaceGenerator/index"));
+exports.AbisInterfaceGenerator = index_1.default;
+const InputsInterfaceGenerator_1 = __importDefault(require("./InputsInterfaceGenerator"));
+exports.InputsInterfaceGenerator = InputsInterfaceGenerator_1.default;
+const ManifestHandler_1 = __importDefault(require("./ManifestHandler"));
+exports.ManifestHandler = ManifestHandler_1.default;

package/dist/log.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const log = {
+    startAction: (text, color) => {
+        log.stopAction();
+        core_1.ux.action.start(core_1.ux.colorize(color, text));
+    },
+    stopAction: (text) => core_1.ux.action.stop(core_1.ux.colorize('green', `${text ? `${text} ` : ''}✔️`)),
+    warnText: (text) => core_1.ux.colorize('red', text),
+    highlightText: (text) => core_1.ux.colorize('yellow', text),
+};
+exports.default = log;

package/dist/templates/manifest.yaml

@@ -0,0 +1,9 @@
+version: 1.0.0
+name: Example Task
+description: Autogenerated example task
+inputs:
+  - chainId: uint32
+  - token: address
+  - amount: uint256
+  - recipient: address
+  - fee: uint256

package/dist/templates/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "mimic-task",
+  "version": "0.0.1",
+  "license": "Unlicensed",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "yarn codegen && yarn compile",
+    "codegen": "mimic codegen",
+    "compile": "mimic compile",
+    "test": "mimic test"
+  },
+  "devDependencies": {
+    "@mimicprotocol/cli": "^0.0.1-rc.0",
+    "@mimicprotocol/lib-ts": "^0.0.1-rc.0",
+    "@mimicprotocol/test-ts": "^0.0.1-rc.0",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^22.10.5",
+    "assemblyscript": "0.27.36",
+    "chai": "^4.3.7",
+    "json-as": "1.0.7",
+    "mocha": "^10.2.0",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
+    "visitor-as": "0.11.4"
+  }
+}

package/dist/templates/src/task.ts

@@ -0,0 +1,7 @@
+import { Transfer } from '@mimicprotocol/lib-ts'
+
+import { inputs } from './types'
+
+export default function main(): void {
+  Transfer.create(inputs.chainId, inputs.token, inputs.amount, inputs.recipient, inputs.fee).send()
+}

package/dist/templates/tests/Task.spec.ts

@@ -0,0 +1,39 @@
+import { runTask } from '@mimicprotocol/test-ts'
+import { expect } from 'chai'
+
+describe('Task', () => {
+  it('produces the expected intents', async () => {
+    const taskDir = './'
+
+    const context = {
+      user: '0x756f45e3fa69347a9a973a725e3c98bc4db0b5a0',
+      settler: '0xdcf1d9d12a0488dfb70a8696f44d6d3bc303963d',
+      timestamp: '1438223173000',
+    }
+
+    const inputs = {
+      chainId: 10,
+      token: '0x7f5c764cbc14f9669b88837ca1490cca17c31607',
+      amount: '10000000',
+      recipient: context.user,
+      fee: '100',
+    }
+
+    const intents = await runTask(taskDir, context, { inputs })
+
+    expect(intents).to.be.an('array').that.is.not.empty
+    expect(intents).to.have.lengthOf(1)
+
+    expect(intents[0].type).to.be.equal('transfer')
+    expect(intents[0].settler).to.be.equal(context.settler)
+    expect(intents[0].user).to.be.equal(context.user)
+    expect(intents[0].chainId).to.be.equal(inputs.chainId)
+    expect(intents[0].feeToken).to.be.equal(inputs.token)
+    expect(intents[0].feeAmount).to.be.equal(inputs.fee)
+
+    expect(intents[0].transfers).to.have.lengthOf(1)
+    expect(intents[0].transfers[0].token).to.be.equal(inputs.token)
+    expect(intents[0].transfers[0].amount).to.be.equal(inputs.amount)
+    expect(intents[0].transfers[0].recipient).to.be.equal(inputs.recipient)
+  })
+})

package/dist/templates/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "assemblyscript/std/assembly.json",
+  "include": ["./**/*.ts"]
+}

package/dist/types.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssemblyPrimitiveTypes = exports.LibTypes = void 0;
+var LibTypes;
+(function (LibTypes) {
+    LibTypes["BigInt"] = "BigInt";
+    LibTypes["Address"] = "Address";
+    LibTypes["Bytes"] = "Bytes";
+    LibTypes["ChainId"] = "ChainId";
+    LibTypes["TokenAmount"] = "TokenAmount";
+})(LibTypes || (exports.LibTypes = LibTypes = {}));
+var AssemblyPrimitiveTypes;
+(function (AssemblyPrimitiveTypes) {
+    AssemblyPrimitiveTypes["u8"] = "u8";
+    AssemblyPrimitiveTypes["u16"] = "u16";
+    AssemblyPrimitiveTypes["u32"] = "u32";
+    AssemblyPrimitiveTypes["u64"] = "u64";
+    AssemblyPrimitiveTypes["i8"] = "i8";
+    AssemblyPrimitiveTypes["i16"] = "i16";
+    AssemblyPrimitiveTypes["i32"] = "i32";
+    AssemblyPrimitiveTypes["i64"] = "i64";
+    AssemblyPrimitiveTypes["bool"] = "bool";
+    AssemblyPrimitiveTypes["string"] = "string";
+    AssemblyPrimitiveTypes["Date"] = "Date";
+})(AssemblyPrimitiveTypes || (exports.AssemblyPrimitiveTypes = AssemblyPrimitiveTypes = {}));

package/dist/validators.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestValidator = exports.SEM_VER_REGEX = void 0;
+const zod_1 = require("zod");
+const String = zod_1.z.string().min(1);
+const SOLIDITY_TYPE_REGEX = /^(u?int(8|16|32|64|128|256)?|bool|address|bytes([1-9]|[1-2][0-9]|3[0-2])?|string)$/;
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+exports.SEM_VER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+exports.ManifestValidator = zod_1.z.object({
+    version: String.regex(exports.SEM_VER_REGEX, 'Must be a valid semver'),
+    name: String,
+    description: String,
+    inputs: zod_1.z.record(String, String.regex(SOLIDITY_TYPE_REGEX, 'Must be a valid solidity type')),
+    abis: zod_1.z.record(String, String),
+    metadata: zod_1.z.object({
+        libVersion: String.regex(exports.SEM_VER_REGEX, 'Must be a valid semver'),
+    }),
+});