@mimicprotocol/cli 0.0.1-rc.21 → 0.0.1-rc.23

package/dist/commands/build.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const codegen_1 = __importDefault(require("./codegen"));
+const compile_1 = __importDefault(require("./compile"));
+class Build extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(Build);
+        const { manifest, task, output, types, clean } = flags;
+        const codegenArgs = ['--manifest', manifest, '--output', types];
+        if (clean)
+            codegenArgs.push('--clean');
+        await codegen_1.default.run(codegenArgs);
+        const compileArgs = ['--task', task, '--manifest', manifest, '--output', output];
+        await compile_1.default.run(compileArgs);
+    }
+}
+Build.description = 'Runs code generation and then compiles the task';
+Build.examples = [
+    '<%= config.bin %> <%= command.id %> --manifest ./manifest.yaml --task src/task.ts --output ./build --types ./src/types',
+];
+Build.flags = {
+    manifest: core_1.Flags.string({ char: 'm', description: 'manifest to use', default: 'manifest.yaml' }),
+    task: core_1.Flags.string({ char: 't', description: 'task to compile', default: 'src/task.ts' }),
+    output: core_1.Flags.string({ char: 'o', description: 'output directory for build artifacts', default: './build' }),
+    types: core_1.Flags.string({ char: 'y', description: 'output directory for generated types', default: './src/types' }),
+    clean: core_1.Flags.boolean({
+        char: 'c',
+        description: 'remove existing generated types before generating new files',
+        default: false,
+    }),
+};
+exports.default = Build;

package/dist/commands/compile.js

@@ -37,10 +37,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const ManifestHandler_1 = __importDefault(require("../lib/ManifestHandler"));
+const packageManager_1 = require("../lib/packageManager");
 const log_1 = __importDefault(require("../log"));
 class Compile extends core_1.Command {
     async run() {
@@ -54,7 +54,6 @@ class Compile extends core_1.Command {
         const manifest = ManifestHandler_1.default.load(this, manifestDir);
         log_1.default.startAction('Compiling');
         const ascArgs = [
-            'asc',
             absTaskFile,
             '--target',
             'release',
@@ -65,7 +64,7 @@ class Compile extends core_1.Command {
             '--transform',
             'json-as/transform',
         ];
-        const result = (0, child_process_1.spawnSync)('yarn', ascArgs, { stdio: 'inherit' });
+        const result = (0, packageManager_1.execBinCommand)('asc', ascArgs, process.cwd());
         if (result.status !== 0) {
             this.error('AssemblyScript compilation failed', {
                 code: 'BuildError',

package/dist/commands/deploy.js

@@ -38,11 +38,11 @@ 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 packageManager_1 = require("../lib/packageManager");
 const log_1 = __importDefault(require("../log"));
 const MIMIC_REGISTRY_DEFAULT = 'https://api-protocol.mimic.fi';
 class Deploy extends core_1.Command {
@@ -52,10 +52,10 @@ class Deploy extends core_1.Command {
         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' });
+            const codegen = (0, packageManager_1.execBinCommand)('mimic', ['codegen'], process.cwd());
             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' });
+            const compile = (0, packageManager_1.execBinCommand)('mimic', ['compile', '--output', fullInputDir], process.cwd());
             if (compile.status !== 0)
                 this.error('Compilation failed', { code: 'BuildError', suggestions: ['Check the task source code'] });
         }

package/dist/commands/init.js

@@ -38,16 +38,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const prompts_1 = require("@inquirer/prompts");
 const core_1 = require("@oclif/core");
-const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const simple_git_1 = __importDefault(require("simple-git"));
+const packageManager_1 = require("../lib/packageManager");
 const log_1 = __importDefault(require("../log"));
 class Init extends core_1.Command {
     async run() {
         const { flags } = await this.parse(Init);
         const { directory, force } = flags;
         const fullDirectory = path.resolve(directory);
-        const templateDirectory = path.join(__dirname, '../templates');
+        const originalCwd = process.cwd();
+        const needsCwdChange = originalCwd === fullDirectory || originalCwd.startsWith(fullDirectory + path.sep);
+        if (needsCwdChange) {
+            const parentDir = path.dirname(fullDirectory);
+            process.chdir(parentDir);
+        }
         if (force && fs.existsSync(fullDirectory) && fs.readdirSync(fullDirectory).length > 0) {
             const shouldDelete = process.env.NODE_ENV === 'test'
                 ? true
@@ -73,7 +79,22 @@ class Init extends core_1.Command {
                 ],
             });
         }
-        fs.cpSync(templateDirectory, fullDirectory, { recursive: true });
+        if (fs.existsSync(fullDirectory) && fs.readdirSync(fullDirectory).length === 0) {
+            fs.rmSync(fullDirectory, { recursive: true });
+        }
+        if (!fs.existsSync(fullDirectory)) {
+            fs.mkdirSync(fullDirectory, { recursive: true });
+        }
+        try {
+            await (0, simple_git_1.default)().clone('https://github.com/mimic-protocol/init-template.git', fullDirectory);
+        }
+        catch (error) {
+            this.error(`Failed to clone template repository. Details: ${error}`);
+        }
+        // Remove .git to make it a fresh project repo
+        const gitDir = path.join(fullDirectory, '.git');
+        if (fs.existsSync(gitDir))
+            fs.rmSync(gitDir, { recursive: true, force: true });
         this.installDependencies(fullDirectory);
         this.runCodegen(fullDirectory);
         log_1.default.stopAction();
@@ -82,16 +103,12 @@ class Init extends core_1.Command {
     installDependencies(fullDirectory) {
         if (process.env.NODE_ENV === 'test')
             return;
-        (0, child_process_1.spawnSync)('yarn', ['install'], {
-            cwd: fullDirectory,
-            stdio: 'inherit',
-        });
+        (0, packageManager_1.installDependencies)(fullDirectory);
     }
     runCodegen(fullDirectory) {
-        (0, child_process_1.spawnSync)('yarn', ['codegen'], {
-            cwd: fullDirectory,
-            stdio: 'inherit',
-        });
+        if (process.env.NODE_ENV === 'test')
+            return;
+        (0, packageManager_1.execBinCommand)('mimic', ['codegen'], fullDirectory);
     }
 }
 Init.description = 'Initializes a new Mimic-compatible project structure in the specified directory';

package/dist/commands/test.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
+const packageManager_1 = require("../lib/packageManager");
 class Test extends core_1.Command {
     runOrExit(cmd, args, cwd) {
         const result = (0, child_process_1.spawnSync)(cmd, args, { cwd, stdio: 'inherit' });
@@ -47,13 +48,14 @@ class Test extends core_1.Command {
         const baseDir = path.resolve(flags.directory);
         const testPath = path.join(baseDir, 'tests');
         if (!flags.skipCompile) {
-            this.runOrExit('yarn', ['mimic', 'codegen'], baseDir);
-            this.runOrExit('yarn', ['mimic', 'compile'], baseDir);
+            const cg = (0, packageManager_1.execBinCommand)('mimic', ['codegen'], baseDir);
+            if (cg.status !== 0)
+                this.exit(cg.status ?? 1);
+            const cp = (0, packageManager_1.execBinCommand)('mimic', ['compile'], baseDir);
+            if (cp.status !== 0)
+                this.exit(cp.status ?? 1);
         }
-        const result = (0, child_process_1.spawnSync)('yarn', ['tsx', './node_modules/mocha/bin/mocha.js', `${testPath}/**/*.spec.ts`], {
-            cwd: baseDir,
-            stdio: 'inherit',
-        });
+        const result = (0, packageManager_1.execBinCommand)('tsx', ['./node_modules/mocha/bin/mocha.js', `${testPath}/**/*.spec.ts`], baseDir);
         this.exit(result.status ?? 1);
     }
 }

package/dist/lib/AbisInterfaceGenerator/FunctionHandler.js

@@ -57,7 +57,7 @@ class FunctionHandler {
     }
     static getReturnType(fn, tupleDefinitions, abiTypeConverter) {
         if (this.isWriteFunction(fn))
-            return 'CallBuilder';
+            return 'EvmCallBuilder';
         if (!fn.outputs || fn.outputs.length === 0)
             return 'void';
         if (fn.outputs.length === 1)
@@ -90,11 +90,15 @@ class FunctionHandler {
         const returnType = this.getReturnType(fn, tupleDefinitions, abiTypeConverter);
         const methodName = fn.escapedName || fn.name;
         const capitalizedName = this.getCapitalizedName(fn);
-        lines.push(`  ${methodName}(${methodParams}): ${returnType} {`);
+        const isPayable = fn.stateMutability === 'payable';
+        const fullMethodParams = methodParams.concat(isPayable ? `${methodParams.length > 0 ? ', ' : ''}value: ${types_1.LibTypes.BigInt}` : '');
+        lines.push(`  ${methodName}(${fullMethodParams}): ${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)`);
+        importManager.addType('EvmCallBuilder');
+        if (isPayable)
+            importManager.addType(types_1.LibTypes.BigInt);
+        lines.push(`    return EvmCallBuilder.forChain(this._chainId).addCall(this._address, encodedData${isPayable ? ', value' : ''})`);
         lines.push(`  }`);
         lines.push('');
     }

package/dist/lib/InputsInterfaceGenerator.js

@@ -33,15 +33,21 @@ function convertInputs(inputs) {
     }));
 }
 function generateImports(inputs) {
-    const typesToImport = new Set(Object.values(inputs).filter((e) => e === 'Address' || e === 'Bytes' || e === 'BigInt'));
-    if (typesToImport.size === 0)
+    const IMPORTABLE_TYPES = new Set(['Address', 'Bytes', 'BigInt', 'TokenAmount', 'BlockchainToken']);
+    const imports = new Set(Object.values(inputs).filter((type) => IMPORTABLE_TYPES.has(type)));
+    if (imports.size === 0)
         return '';
-    return `import { ${[...typesToImport].sort().join(', ')} } from '@mimicprotocol/lib-ts'`;
+    return `import { ${[...imports].sort().join(', ')} } from '@mimicprotocol/lib-ts'`;
 }
 function generateInputsMapping(inputs, originalInputs) {
     return Object.entries(inputs)
         .map(([name, type]) => {
-        const declaration = type === 'string' || type === 'Address' || type === 'Bytes' || type === 'BigInt'
+        const declaration = type === 'string' ||
+            type === 'Address' ||
+            type === 'Bytes' ||
+            type === 'BigInt' ||
+            type === 'BlockchainToken' ||
+            type === 'TokenAmount'
             ? `var ${name}: string | null`
             : `const ${name}: ${type}`;
         const originalInput = originalInputs[name];
@@ -75,6 +81,10 @@ function convertType(type) {
         return 'Address';
     if (type.includes('bytes'))
         return 'Bytes';
+    if (type === 'Token')
+        return 'BlockchainToken';
+    if (type === 'TokenAmount')
+        return 'TokenAmount';
     return type;
 }
 function generateGetter(name, type) {
@@ -88,6 +98,10 @@ function generateGetter(name, type) {
         returnStr = `Bytes.fromHexString(${str}!)`;
     else if (type === 'BigInt')
         returnStr = `BigInt.fromString(${str}!)`;
+    else if (type === 'BlockchainToken')
+        returnStr = `BlockchainToken.fromSerializable(${str}!)`;
+    else if (type === 'TokenAmount')
+        returnStr = `TokenAmount.fromSerializable(${str}!)`;
     else
         returnStr = str;
     return `static get ${name}(): ${type} {

package/dist/lib/packageManager.js

@@ -0,0 +1,90 @@
+"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 });
+exports.execBinCommand = exports.installDependencies = exports.detectPackageManager = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const detectFromUserAgent = () => {
+    const ua = process.env.npm_config_user_agent || '';
+    if (ua.includes('pnpm/'))
+        return 'pnpm';
+    if (ua.includes('yarn/'))
+        return 'yarn';
+    if (ua.includes('bun/'))
+        return 'bun';
+    if (ua.includes('npm/'))
+        return 'npm';
+    return undefined;
+};
+const detectFromLockfiles = (cwd) => {
+    const files = [
+        ['pnpm', 'pnpm-lock.yaml'],
+        ['yarn', 'yarn.lock'],
+        ['npm', 'package-lock.json'],
+        ['bun', 'bun.lockb'],
+    ];
+    for (const [pm, file] of files) {
+        if (fs.existsSync(path.join(cwd, file)))
+            return pm;
+    }
+    return undefined;
+};
+const detectPackageManager = (cwd) => {
+    return detectFromUserAgent() || detectFromLockfiles(cwd) || 'npm';
+};
+exports.detectPackageManager = detectPackageManager;
+const installDependencies = (cwd) => {
+    const pm = (0, exports.detectPackageManager)(cwd);
+    if (pm === 'npm')
+        return (0, child_process_1.spawnSync)('npm', ['install'], { cwd, stdio: 'inherit' });
+    if (pm === 'pnpm')
+        return (0, child_process_1.spawnSync)('pnpm', ['install'], { cwd, stdio: 'inherit' });
+    if (pm === 'yarn')
+        return (0, child_process_1.spawnSync)('yarn', ['install'], { cwd, stdio: 'inherit' });
+    if (pm === 'bun')
+        return (0, child_process_1.spawnSync)('bun', ['install'], { cwd, stdio: 'inherit' });
+    return (0, child_process_1.spawnSync)('npm', ['install'], { cwd, stdio: 'inherit' });
+};
+exports.installDependencies = installDependencies;
+const execBinCommand = (bin, args, cwd) => {
+    const localBin = path.join(cwd, 'node_modules', '.bin', bin);
+    if (fs.existsSync(localBin)) {
+        return (0, child_process_1.spawnSync)(localBin, args, { cwd, stdio: 'inherit' });
+    }
+    // Fallback to spawning the bin directly (global or resolved in PATH)
+    return (0, child_process_1.spawnSync)(bin, args, { cwd, stdio: 'inherit' });
+};
+exports.execBinCommand = execBinCommand;

package/dist/validators.js

@@ -3,17 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManifestValidator = exports.SEM_VER_REGEX = void 0;
 const zod_1 = require("zod");
 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)$/;
+const TOKEN_TYPE_REGEX = /^(Token|TokenAmount)$/;
 // 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-]+)*))?$/;
 const String = zod_1.z.string().min(1);
 const SolidityType = String.regex(SOLIDITY_TYPE_REGEX, 'Must be a valid solidity type');
-const InputValue = zod_1.z.union([
-    SolidityType,
-    zod_1.z.object({
-        type: SolidityType,
-        description: String.optional(),
-    }),
-]);
+const TokenType = String.regex(TOKEN_TYPE_REGEX, 'Must be a valid token type');
+const InputType = zod_1.z.union([SolidityType, TokenType]);
+const InputValue = zod_1.z.union([InputType, zod_1.z.object({ type: InputType, description: String.optional() })]);
 exports.ManifestValidator = zod_1.z.object({
     version: String.regex(exports.SEM_VER_REGEX, 'Must be a valid semver'),
     name: String,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimicprotocol/cli",
-  "version": "0.0.1-rc.21",
+  "version": "0.0.1-rc.23",
   "license": "GPL-3.0",
   "private": false,
   "type": "commonjs",
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "prepare": "yarn build",
-    "build": "rm -rf dist && tsc && cp -r src/templates dist/templates",
+    "build": "rm -rf dist && tsc",
     "start": "yarn build && node ./bin/run.js",
     "test": "yarn build && ts-mocha ./tests --recursive --extension .spec.ts --exit --timeout 5000",
     "lint": "eslint ."
@@ -27,6 +27,7 @@
     "form-data": "^4.0.1",
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
+    "simple-git": "^3.30.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {

package/dist/templates/eslint.config.mjs

@@ -1,89 +0,0 @@
-import eslintPluginTypeScript from "@typescript-eslint/eslint-plugin"
-import eslintParserTypeScript from "@typescript-eslint/parser"
-import eslintPluginImport from "eslint-plugin-import"
-import eslintPluginSimpleImportSort from "eslint-plugin-simple-import-sort"
-import eslintConfigPrettier from "eslint-config-prettier"
-import eslintPluginPrettier from "eslint-plugin-prettier"
-
-export default [
-  {
-    ignores: ["node_modules/**", "**/dist/**", "**/build/**", "**/.prettierrc.*", "./src/types/**"]
-  },
-  {
-    files: ["**/*.{ts,tsx}"],
-    languageOptions: {
-      ecmaVersion: "latest",
-      sourceType: "module",
-      parser: eslintParserTypeScript,
-      parserOptions: {
-        project: "./tsconfig.json"
-      }
-    },
-    plugins: {
-      "@typescript-eslint": eslintPluginTypeScript,
-      prettier: eslintPluginPrettier,
-      import: eslintPluginImport,
-      "simple-import-sort": eslintPluginSimpleImportSort
-    },
-    rules: {
-      ...eslintPluginTypeScript.configs.recommended.rules,
-      "@typescript-eslint/no-namespace": "off",
-      "@typescript-eslint/no-unused-vars": ["error"],
-      "@typescript-eslint/explicit-function-return-type": "error",
-      "@typescript-eslint/no-explicit-any": "error",
-      
-      "prettier/prettier": [
-        "error",
-        {
-          "semi": false,
-          "singleQuote": true,
-          "trailingComma": "es5",
-          "arrowParens": "always",
-          "bracketSpacing": true,
-          "printWidth": 120,
-          "tabWidth": 2,
-          "useTabs": false
-        }
-      ],
-      
-      "simple-import-sort/imports": [
-        "error",
-        {
-          groups: [
-            ["^@?\\w"],
-            ["^\\.\\.(?!/?$)", "^\\.\\./?$"],
-            ["^\\./(?=.*/)(?!/?$)", "^\\.(?!/?$)", "^\\./?$"]
-          ]
-        }
-      ],
-      "simple-import-sort/exports": "error",
-      
-      "comma-spacing": ["error", { before: false, after: true }],
-      "no-multiple-empty-lines": ["error", { max: 1, maxEOF: 1 }]
-    },
-    settings: {
-      "import/resolver": {
-        typescript: {
-          alwaysTryTypes: true,
-          project: "./tsconfig.json"
-        }
-      }
-    }
-  },
-  // configuration for test files
-  {
-    files: ["tests/**/*.{ts,tsx}", "**/*.spec.{ts,tsx}", "**/*.test.{ts,tsx}"],
-    languageOptions: {
-      ecmaVersion: "latest",
-      sourceType: "module",
-      parser: eslintParserTypeScript,
-      parserOptions: {
-        project: "./tests/tsconfig.json"
-      }
-    },
-    rules: {
-      "@typescript-eslint/no-unused-expressions": "off"
-    }
-  },
-  eslintConfigPrettier
-]

package/dist/templates/manifest.yaml

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

package/dist/templates/package.json

@@ -1,30 +0,0 @@
-{
-  "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",
-    "lint": "eslint ."
-  },
-  "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/chai": "^5.2.2",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^22.10.5",
-    "assemblyscript": "0.27.36",
-    "chai": "^4.3.7",
-    "eslint": "^9.10.0",
-    "json-as": "1.1.7",
-    "mocha": "^10.2.0",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.3",
-    "visitor-as": "0.11.4"
-  }
-}

package/dist/templates/src/task.ts

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

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

@@ -1,40 +0,0 @@
-import { runTask, Transfer } from '@mimicprotocol/test-ts'
-import { expect } from 'chai'
-
-describe('Task', () => {
-  const taskDir = './'
-
-  const context = {
-    user: '0x756f45e3fa69347a9a973a725e3c98bc4db0b5a0',
-    settlers: [{ address: '0xdcf1d9d12a0488dfb70a8696f44d6d3bc303963d', chainId: 10 }],
-    timestamp: Date.now(),
-  }
-
-  const inputs = {
-    chainId: 10, // Optimism
-    token: '0x7f5c764cbc14f9669b88837ca1490cca17c31607', // USDC
-    amount: '1000000', // 1 USDC
-    recipient: '0xbce3248ede29116e4bd18416dcc2dfca668eeb84',
-    maxFee: '100000', // 0.1 USDC
-  }
-
-  it('produces the expected intents', async () => {
-    const intents = (await runTask(taskDir, context, { inputs })) as Transfer[]
-
-    expect(intents).to.be.an('array')
-    expect(intents).to.have.lengthOf(1)
-
-    expect(intents[0].type).to.be.equal('transfer')
-    expect(intents[0].settler).to.be.equal(context.settlers[0].address)
-    expect(intents[0].user).to.be.equal(context.user)
-    expect(intents[0].chainId).to.be.equal(inputs.chainId)
-    expect(intents[0].maxFees).to.have.lengthOf(1)
-    expect(intents[0].maxFees[0].token).to.be.equal(inputs.token)
-    expect(intents[0].maxFees[0].amount).to.be.equal(inputs.maxFee)
-
-    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/tests/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "declaration": true,
-    "composite": true,
-    "outDir": "./dist",
-    "rootDir": "./",
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "lib": ["ES2020", "DOM"],
-    "types": ["mocha", "chai", "node"]
-  },
-  "include": ["./**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}

package/dist/templates/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "assemblyscript/std/assembly.json",
-  "include": ["./src/**/*.ts"],
-  "exclude": ["tests/**/*"],
-  "references": [{ "path": "./tests" }]
-}