@mimicprotocol/cli 0.0.1-rc.31 → 0.0.1-rc.34

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @mimicprotocol/cli
 
+## 0.0.1-rc.34
+
+### Patch Changes
+
+- 73a7900: Add login, logout and profiles commands
+- d455822: Bump SDK version
+
+## 0.0.1-rc.33
+
+### Patch Changes
+
+- 9530e1c: Revert test command directory change
+- 21aba8d: Improve mocks error messages
+- 5c8c562: Fix MockConfig validator
+
+## 0.0.1-rc.32
+
+### Patch Changes
+
+- 8853afe: Fix clashing Result import
+- e1277c7: Refactor Result to use unwrap instead of value
+- 323663a: Change directory to positional argument in init and test command
+- faac37c: Ensure early returns in favor of else blocks
+
 ## 0.0.1-rc.31
 
 ### Patch Changes

package/README.md

@@ -23,9 +23,10 @@
 
 ---
 
-## Content 
+## Content
 
 The `mimic` CLI is a command-line interface to:
+
 - Initialize a Mimic-compatible task project
 - Generate types from your task manifest and ABIs
 - Compile your AssemblyScript tasks to WebAssembly
@@ -35,7 +36,7 @@ The `mimic` CLI is a command-line interface to:
 
 ## Setup
 
-To set up this project you'll need [git](https://git-scm.com) and [yarn](https://classic.yarnpkg.com) installed. 
+To set up this project you'll need [git](https://git-scm.com) and [yarn](https://classic.yarnpkg.com) installed.
 
 Install the CLI from the root of the monorepo:
 
@@ -59,6 +60,9 @@ USAGE
   $ mimic [COMMAND]
 
 COMMANDS
+  login    Authenticate with Mimic by storing your API key locally
+  logout   Remove stored credentials for a profile
+  profiles List all configured authentication profiles
   codegen  Generates typed interfaces for declared inputs and ABIs from your manifest.yaml file
   compile  Compiles task
   test     Tests your tasks
@@ -66,6 +70,69 @@ COMMANDS
   init     Initializes a new Mimic-compatible project structure in the specified directory
 ```
 
+### Authentication
+
+Before deploying tasks, you need to authenticate with your Mimic API key:
+
+```bash
+# Interactive login (recommended)
+$ mimic login
+
+# Non-interactive login (for CI/CD)
+$ mimic login --api-key YOUR_API_KEY
+
+# Login with a specific profile
+$ mimic login --profile staging -api-key YOUR_API_KEY
+```
+
+#### Managing Profiles
+
+The CLI supports multiple authentication profiles. Credentials are stored in `~/.mimic/credentials`.
+
+```bash
+# List all configured profiles
+$ mimic profiles
+
+# Login with a specific profile
+$ mimic login --profile production
+
+# Deploy using a specific profile
+$ mimic deploy --profile production
+
+# Remove credentials for a profile
+$ mimic logout --profile staging
+```
+
+#### Credential Storage
+
+Credentials are stored in an INI-style format at `~/.mimic/credentials`:
+
+```ini
+[default]
+api_key=YOUR_DEFAULT_KEY
+
+[staging]
+api_key=YOUR_STAGING_KEY
+
+[production]
+api_key=YOUR_PRODUCTION_KEY
+```
+
+#### Deploy with Authentication
+
+The `deploy` command now supports profile-based authentication:
+
+```bash
+# Deploy using default profile
+$ mimic deploy
+
+# Deploy using a specific profile
+$ mimic deploy --profile staging
+
+# Deploy with explicit API key (overrides profile)
+$ mimic deploy --api-key YOUR_API_KEY
+```
+
 For full CLI documentation and examples please visit [docs.mimic.fi](https://docs.mimic.fi/)
 
 ## Security
@@ -86,7 +153,6 @@ This project includes code from [The Graph Tooling](https://github.com/graphprot
 See the [LICENSE-MIT](https://github.com/graphprotocol/graph-tooling/blob/27659e56adfa3ef395ceaf39053dc4a31e6d86b7/LICENSE-MIT) file for details.
 Their original license and attribution are preserved.
 
-
 ---
 
 > Website [mimic.fi](https://mimic.fi)  · 

package/dist/commands/authenticate.js

@@ -0,0 +1,54 @@
+"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 CredentialsManager_1 = require("../lib/CredentialsManager");
+const log_1 = __importDefault(require("../log"));
+class Authenticate extends core_1.Command {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    run() {
+        throw new Error('Method not implemented.');
+    }
+    authenticate(flags) {
+        let apiKey = flags['api-key'];
+        if (!apiKey) {
+            try {
+                const credentials = CredentialsManager_1.CredentialsManager.getDefault().getCredentials(flags.profile);
+                apiKey = credentials.apiKey;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    this.error(error.message, {
+                        code: 'AuthenticationRequired',
+                        suggestions: [
+                            `Run ${log_1.default.highlightText('mimic login')} to authenticate`,
+                            `Run ${log_1.default.highlightText(`mimic login --profile ${flags.profile ?? '<profile>'}`)} to create this profile`,
+                            `Or use ${log_1.default.highlightText('--api-key')} flag to provide API key directly`,
+                        ].filter(Boolean),
+                    });
+                }
+                throw error;
+            }
+        }
+        return { apiKey };
+    }
+}
+Authenticate.description = 'Authenticate with Mimic by storing your API key locally';
+Authenticate.examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --profile staging',
+    '<%= config.bin %> <%= command.id %> --profile production --api-key YOUR_API_KEY',
+];
+Authenticate.flags = {
+    profile: core_1.Flags.string({
+        char: 'p',
+        description: 'Profile name to use for this credential',
+    }),
+    'api-key': core_1.Flags.string({
+        char: 'k',
+        description: 'API key (non-interactive mode)',
+    }),
+};
+exports.default = Authenticate;

package/dist/commands/deploy.js

@@ -44,13 +44,15 @@ const path_1 = require("path");
 const errors_1 = require("../errors");
 const packageManager_1 = require("../lib/packageManager");
 const log_1 = __importDefault(require("../log"));
+const authenticate_1 = __importDefault(require("./authenticate"));
 const MIMIC_REGISTRY_DEFAULT = 'https://api-protocol.mimic.fi';
-class Deploy extends core_1.Command {
+class Deploy extends authenticate_1.default {
     async run() {
         const { flags } = await this.parse(Deploy);
-        const { key, input: inputDir, output: outputDir, 'skip-compile': skipCompile, url: registryUrl } = flags;
+        const { input: inputDir, output: outputDir, 'skip-compile': skipCompile, url: registryUrl } = flags;
         const fullInputDir = (0, path_1.resolve)(inputDir);
         const fullOutputDir = (0, path_1.resolve)(outputDir);
+        let credentials = this.authenticate(flags);
         if (!skipCompile) {
             const codegen = (0, packageManager_1.execBinCommand)('mimic', ['codegen'], process.cwd());
             if (codegen.status !== 0)
@@ -74,7 +76,7 @@ class Deploy extends core_1.Command {
                 });
         }
         log_1.default.startAction('Uploading to Mimic Registry');
-        const CID = await this.uploadToRegistry(neededFiles, key, registryUrl);
+        const CID = await this.uploadToRegistry(neededFiles, credentials, registryUrl);
         console.log(`IPFS CID: ${log_1.default.highlightText(CID)}`);
         log_1.default.stopAction();
         if (!fs.existsSync(fullOutputDir))
@@ -83,12 +85,12 @@ class Deploy extends core_1.Command {
         console.log(`CID saved at ${log_1.default.highlightText(fullOutputDir)}`);
         console.log(`Task deployed!`);
     }
-    async uploadToRegistry(files, key, registryUrl) {
+    async uploadToRegistry(files, credentials, registryUrl) {
         try {
             const form = filesToForm(files);
             const { data } = await axios_1.default.post(`${registryUrl}/tasks`, form, {
                 headers: {
-                    'x-api-key': key,
+                    'x-api-key': credentials.apiKey,
                     'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`,
                 },
             });
@@ -114,9 +116,13 @@ class Deploy extends core_1.Command {
     }
 }
 Deploy.description = 'Uploads your compiled task artifacts to IPFS and registers it into the Mimic Registry';
-Deploy.examples = ['<%= config.bin %> <%= command.id %> --input ./dist --key MY_KEY --output ./dist'];
+Deploy.examples = [
+    '<%= config.bin %> <%= command.id %> --input ./dist --output ./dist',
+    '<%= config.bin %> <%= command.id %> --profile staging',
+    '<%= config.bin %> <%= command.id %> --api-key MY_KEY --input ./dist --output ./dist',
+];
 Deploy.flags = {
-    key: core_1.Flags.string({ char: 'k', description: 'Your account deployment key', required: true }),
+    ...authenticate_1.default.flags,
     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 }),

package/dist/commands/init.js

@@ -45,8 +45,9 @@ 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 { args, flags } = await this.parse(Init);
+        const { directory } = args;
+        const { force } = flags;
         const fullDirectory = path.resolve(directory);
         if (force && fs.existsSync(fullDirectory) && fs.readdirSync(fullDirectory).length > 0) {
             const shouldDelete = process.env.NODE_ENV === 'test'
@@ -73,7 +74,7 @@ class Init extends core_1.Command {
             this.error(`Directory ${log_1.default.highlightText(fullDirectory)} is not empty`, {
                 code: 'DirectoryNotEmpty',
                 suggestions: [
-                    'You can specify the directory with --directory',
+                    'You can specify the directory as a positional argument',
                     `You can ${log_1.default.warnText('overwrite')} an existing directory with --force`,
                 ],
             });
@@ -107,9 +108,11 @@ class Init extends core_1.Command {
     }
 }
 Init.description = 'Initializes a new Mimic-compatible project structure in the specified directory';
-Init.examples = ['<%= config.bin %> <%= command.id %> --directory ./new-project --force'];
+Init.examples = ['<%= config.bin %> <%= command.id %> ./new-project --force'];
+Init.args = {
+    directory: core_1.Args.string({ description: 'Directory to initialize project', required: false, default: './' }),
+};
 Init.flags = {
-    directory: core_1.Flags.string({ char: 'd', description: 'Directory to initialize project', default: './' }),
     force: core_1.Flags.boolean({ char: 'f', description: 'Overwrite existing files if they already exist', default: false }),
 };
 exports.default = Init;

package/dist/commands/login.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = require("@inquirer/prompts");
+const core_1 = require("@oclif/core");
+const CredentialsManager_1 = require("../lib/CredentialsManager");
+const log_1 = __importDefault(require("../log"));
+const authenticate_1 = __importDefault(require("./authenticate"));
+class Login extends authenticate_1.default {
+    async run() {
+        const { flags } = await this.parse(Login);
+        const { profile: profileInput, 'api-key': apiKeyFlag } = flags;
+        let apiKey;
+        let profileName = profileInput;
+        // Non-interactive mode
+        if (apiKeyFlag)
+            apiKey = apiKeyFlag;
+        else {
+            // Interactive mode
+            try {
+                apiKey = await (0, prompts_1.password)({
+                    message: 'Enter your API key:',
+                    mask: '*',
+                    validate: (value) => {
+                        if (!value || value.trim() === '')
+                            return 'API key cannot be empty';
+                        return true;
+                    },
+                });
+                if (!profileName) {
+                    profileName = await (0, prompts_1.input)({
+                        message: `Enter a profile name (press Enter for "${CredentialsManager_1.CredentialsManager.getDefaultProfileName()}"):`,
+                        default: CredentialsManager_1.CredentialsManager.getDefaultProfileName(),
+                        validate: (value) => {
+                            if (!value || value.trim() === '')
+                                return 'Profile name cannot be empty';
+                            if (value.includes('[') || value.includes(']') || value.includes('=')) {
+                                return 'Profile name cannot contain [, ], or = characters';
+                            }
+                            return true;
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('User force closed')) {
+                    console.log('\nLogin cancelled');
+                    this.exit(0);
+                }
+                throw error;
+            }
+        }
+        this.saveAndConfirm(profileName || CredentialsManager_1.CredentialsManager.getDefaultProfileName(), apiKey, flags['force-login']);
+    }
+    async saveAndConfirm(profileName, apiKey, forceLogin) {
+        try {
+            const credentialsManager = CredentialsManager_1.CredentialsManager.getDefault();
+            if (credentialsManager.profileExists(profileName) && !forceLogin) {
+                const shouldOverwrite = await (0, prompts_1.confirm)({
+                    message: `Profile ${log_1.default.highlightText(profileName)} already exists. Overwrite?`,
+                    default: false,
+                });
+                if (!shouldOverwrite) {
+                    console.log('Login cancelled');
+                    return;
+                }
+            }
+            log_1.default.startAction('Saving credentials');
+            credentialsManager.saveProfile(profileName, apiKey);
+            log_1.default.stopAction();
+            console.log(`✓ Credentials saved for profile ${log_1.default.highlightText(profileName)}`);
+            console.log(`  Location: ${log_1.default.highlightText('~/.mimic/credentials')}`);
+            console.log();
+            console.log(`You can now deploy tasks using: ${log_1.default.highlightText('mimic deploy')}`);
+            if (profileName !== CredentialsManager_1.CredentialsManager.getDefaultProfileName()) {
+                console.log(`Or with your profile: ${log_1.default.highlightText(`mimic deploy --profile ${profileName}`)}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error)
+                this.error(`Failed to save credentials: ${error.message}`);
+            throw error;
+        }
+    }
+}
+Login.description = 'Authenticate with Mimic by storing your API key locally';
+Login.examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --profile staging',
+    '<%= config.bin %> <%= command.id %> --profile production --api-key YOUR_API_KEY',
+];
+Login.flags = {
+    ...authenticate_1.default.flags,
+    'force-login': core_1.Flags.boolean({
+        char: 'f',
+        description: 'Force login even if profile exists',
+        default: false,
+    }),
+};
+exports.default = Login;

package/dist/commands/logout.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompts_1 = require("@inquirer/prompts");
+const core_1 = require("@oclif/core");
+const CredentialsManager_1 = require("../lib/CredentialsManager");
+const log_1 = __importDefault(require("../log"));
+class Logout extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(Logout);
+        const { profile: profileName, force } = flags;
+        const profiles = CredentialsManager_1.CredentialsManager.getDefault().getProfiles();
+        if (!profiles.includes(profileName)) {
+            this.error(`Profile '${profileName}' does not exist`, {
+                code: 'ProfileNotFound',
+                suggestions: profiles.length > 0
+                    ? [`Available profiles: ${profiles.join(', ')}`]
+                    : ['No profiles found. Use `mimic login` to create one.'],
+            });
+        }
+        if (!force) {
+            const shouldRemove = await (0, prompts_1.confirm)({
+                message: `Are you sure you want to remove credentials for profile ${log_1.default.highlightText(profileName)}?`,
+                default: false,
+            });
+            if (!shouldRemove) {
+                console.log('Logout cancelled');
+                this.exit(0);
+            }
+        }
+        log_1.default.startAction(`Removing credentials for profile ${profileName}`);
+        CredentialsManager_1.CredentialsManager.getDefault().removeProfile(profileName);
+        log_1.default.stopAction();
+        console.log(`✓ Credentials removed for profile ${log_1.default.highlightText(profileName)}`);
+    }
+}
+Logout.description = 'Remove stored credentials for a profile';
+Logout.examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --profile staging',
+];
+Logout.flags = {
+    profile: core_1.Flags.string({
+        char: 'p',
+        description: 'Profile name to remove',
+        default: CredentialsManager_1.CredentialsManager.getDefaultProfileName(),
+    }),
+    force: core_1.Flags.boolean({
+        char: 'f',
+        description: 'Skip confirmation prompt',
+        default: false,
+    }),
+};
+exports.default = Logout;

package/dist/commands/profiles.js

@@ -0,0 +1,29 @@
+"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 CredentialsManager_1 = require("../lib/CredentialsManager");
+const log_1 = __importDefault(require("../log"));
+class Profiles extends core_1.Command {
+    async run() {
+        const profiles = CredentialsManager_1.CredentialsManager.getDefault().getProfiles();
+        if (profiles.length === 0) {
+            console.log('No profiles found.');
+            console.log();
+            console.log(`Run ${log_1.default.highlightText('mimic login')} to create your first profile.`);
+            return;
+        }
+        console.log(`Configured profiles (stored in ${log_1.default.highlightText('~/.mimic/credentials')}):`);
+        console.log();
+        for (const profile of profiles) {
+            console.log(`* ${log_1.default.highlightText(profile)}${profile === CredentialsManager_1.CredentialsManager.getDefaultProfileName() ? ' (default)' : ''}`);
+        }
+        console.log();
+        console.log(`Use ${log_1.default.highlightText('mimic deploy --profile <name>')} to deploy with a specific profile.`);
+    }
+}
+Profiles.description = 'List all configured authentication profiles';
+Profiles.examples = ['<%= config.bin %> <%= command.id %>'];
+exports.default = Profiles;

package/dist/commands/test.js

@@ -34,20 +34,15 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 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' });
-        if (result.status !== 0)
-            this.exit(result.status ?? 1);
-    }
     async run() {
         const { flags } = await this.parse(Test);
-        const baseDir = path.resolve(flags.directory);
+        const { directory, 'skip-compile': skipCompile } = flags;
+        const baseDir = path.resolve(directory);
         const testPath = path.join(baseDir, 'tests');
-        if (!flags.skipCompile) {
+        if (!skipCompile) {
             const cg = (0, packageManager_1.execBinCommand)('mimic', ['codegen'], baseDir);
             if (cg.status !== 0)
                 this.exit(cg.status ?? 1);
@@ -63,6 +58,6 @@ Test.description = 'Runs task tests';
 Test.examples = ['<%= config.bin %> <%= command.id %> --directory ./'];
 Test.flags = {
     directory: core_1.Flags.string({ char: 'd', description: 'task directory', default: './' }),
-    skipCompile: core_1.Flags.boolean({ description: 'skip codegen and compile steps' }),
+    'skip-compile': core_1.Flags.boolean({ description: 'skip codegen and compile steps' }),
 };
 exports.default = Test;

package/dist/lib/AbisInterfaceGenerator/FunctionHandler.js

@@ -91,14 +91,18 @@ class FunctionHandler {
         const methodName = fn.escapedName || fn.name;
         const capitalizedName = this.getCapitalizedName(fn);
         const isPayable = fn.stateMutability === 'payable';
-        const fullMethodParams = methodParams.concat(isPayable ? `${methodParams.length > 0 ? ', ' : ''}value: ${types_1.LibTypes.BigInt}` : '');
+        const hasValueParameter = inputs.some((input) => input.escapedName === 'value');
+        const payableParamName = isPayable && hasValueParameter ? '_payableValue' : 'value';
+        const fullMethodParams = methodParams.concat(isPayable
+            ? `${methodParams.length > 0 ? ', ' : ''}${payableParamName}: ${types_1.LibTypes.BigInt} = ${types_1.LibTypes.BigInt}.zero()`
+            : '');
         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('EvmCallBuilder');
         if (isPayable)
             importManager.addType(types_1.LibTypes.BigInt);
-        lines.push(`return EvmCallBuilder.forChain(this._chainId).addCall(this._address, encodedData${isPayable ? ', value' : ''})`);
+        lines.push(`return EvmCallBuilder.forChain(this._chainId).addCall(this._address, encodedData${isPayable ? `, ${payableParamName}` : ''})`);
         lines.push(`}`);
         lines.push('');
     }
@@ -113,18 +117,21 @@ class FunctionHandler {
         const isVoid = returnType === 'void';
         if (isVoid)
             importManager.addType(types_1.LibTypes.Void);
-        const resultReturnType = isVoid ? `Result<${types_1.LibTypes.Void}, string>` : `Result<${returnType}, string>`;
+        const resultIdentifier = NameManager_1.default.getImportNameForCode('Result');
+        const resultReturnType = isVoid
+            ? `${resultIdentifier}<${types_1.LibTypes.Void}, string>`
+            : `${resultIdentifier}<${returnType}, string>`;
         lines.push(`${methodName}(${methodParams}): ${resultReturnType} {`);
         lines.push(`const encodedData = ${contractName}Utils.encode${capitalizedName}(${inputs.map((p) => p.escapedName).join(', ')})`);
         const contractCallLine = `environment.evmCallQuery(this._address, this._chainId, encodedData.toHexString(), this._timestamp)`;
         lines.push(`const response = ${contractCallLine}`);
-        lines.push(`if (response.isError) return Result.err<${isVoid ? types_1.LibTypes.Void : returnType}, string>(response.error)`);
+        lines.push(`if (response.isError) return ${resultIdentifier}.err<${isVoid ? types_1.LibTypes.Void : returnType}, string>(response.error)`);
         if (isVoid) {
-            lines.push(`return Result.ok<${types_1.LibTypes.Void}, string>(new ${types_1.LibTypes.Void}())`);
+            lines.push(`return ${resultIdentifier}.ok<${types_1.LibTypes.Void}, string>(new ${types_1.LibTypes.Void}())`);
         }
         else {
-            lines.push(`const decoded = ${contractName}Utils.decode${capitalizedName}(response.value)`);
-            lines.push(`return Result.ok<${returnType}, string>(decoded)`);
+            lines.push(`const decoded = ${contractName}Utils.decode${capitalizedName}(response.unwrap())`);
+            lines.push(`return ${resultIdentifier}.ok<${returnType}, string>(decoded)`);
         }
         lines.push(`}`);
         lines.push('');

package/dist/lib/AbisInterfaceGenerator/ImportManager.js

@@ -1,5 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const NameManager_1 = __importDefault(require("./NameManager"));
 class ImportManager {
     constructor() {
         this.types = new Set();
@@ -11,7 +15,8 @@ class ImportManager {
         if (this.types.size === 0)
             return '';
         const sortedTypes = [...this.types].sort((a, b) => String(a).localeCompare(String(b)));
-        return `import { ${sortedTypes.join(', ')} } from '@mimicprotocol/lib-ts'`;
+        const importIdentifiers = sortedTypes.map((type) => NameManager_1.default.formatImportStatement(type));
+        return `import { ${importIdentifiers.join(', ')} } from '@mimicprotocol/lib-ts'`;
     }
 }
 exports.default = ImportManager;

package/dist/lib/AbisInterfaceGenerator/NameManager.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NameContext = void 0;
-const types_1 = require("../../types");
 var NameContext;
 (function (NameContext) {
     NameContext["FUNCTION_PARAMETER"] = "function_parameter";
     NameContext["LOCAL_VARIABLE"] = "local_variable";
     NameContext["CLASS_PROPERTY"] = "class_property";
     NameContext["METHOD_NAME"] = "method_name";
-    NameContext["TUPLE_CLASS_NAME"] = "tuple_class_name";
 })(NameContext || (exports.NameContext = NameContext = {}));
 class NameManager {
     static resolveNameConflicts(names, context) {
@@ -41,6 +39,17 @@ class NameManager {
             escapedName: resolvedNames[index],
         }));
     }
+    static getImportNameForCode(type) {
+        const alias = this.getImportAlias(type);
+        return alias ?? type;
+    }
+    static formatImportStatement(type) {
+        const alias = this.getImportAlias(type);
+        return alias ? `${type} as ${alias}` : type;
+    }
+    static getImportAlias(type) {
+        return this.IMPORT_ALIASES[type] ?? null;
+    }
     static hasConflict(name, context) {
         if (this.RESERVED_BY_CONTEXT[context]?.has(name))
             return true;
@@ -68,13 +77,14 @@ class NameManager {
                 return '_prop';
             case NameContext.METHOD_NAME:
                 return '_';
-            case NameContext.TUPLE_CLASS_NAME:
-                return '_class';
             default:
                 return '_safe';
         }
     }
 }
+NameManager.IMPORT_ALIASES = {
+    Result: '_Result',
+};
 NameManager.RESERVED_BY_CONTEXT = {
     [NameContext.FUNCTION_PARAMETER]: new Set([
         'response',
@@ -97,7 +107,6 @@ NameManager.RESERVED_BY_CONTEXT = {
         'timestamp',
     ]),
     [NameContext.METHOD_NAME]: new Set(['constructor']),
-    [NameContext.TUPLE_CLASS_NAME]: new Set([...Object.values(types_1.LibTypes), 'JSON']),
 };
 NameManager.INTERNAL_NAME_PATTERNS = [/^item\d+$/, /^s\d+$/];
 exports.default = NameManager;

package/dist/lib/AbisInterfaceGenerator/TupleHandler.js

@@ -103,7 +103,6 @@ class TupleHandler {
                 if (structMatch && structMatch[1])
                     className = structMatch[1];
             }
-            className = NameManager_1.default.escapeName(className, NameManager_1.NameContext.TUPLE_CLASS_NAME);
             const key = baseInternalType || className;
             const components = this.resolveComponentNames(tupleToDefine.components, NameManager_1.NameContext.CLASS_PROPERTY);
             tupleDefinitions.set(key, {

package/dist/lib/CredentialsManager.js

@@ -0,0 +1,181 @@
+"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.CredentialsManager = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const CREDENTIALS_FILE = 'credentials';
+const DEFAULT_PROFILE = 'default';
+class CredentialsManager {
+    static getDefault() {
+        return new CredentialsManager();
+    }
+    static getCredentialsFileName() {
+        return CREDENTIALS_FILE;
+    }
+    static getDefaultProfileName() {
+        return DEFAULT_PROFILE;
+    }
+    constructor(baseDir) {
+        this.baseDir = baseDir || path.join(os.homedir(), '.mimic');
+    }
+    getBaseDir() {
+        return this.baseDir;
+    }
+    getCredentialsPath() {
+        return path.join(this.getBaseDir(), CREDENTIALS_FILE);
+    }
+    createCredentialsDirIfNotExists() {
+        if (fs.existsSync(this.getBaseDir()))
+            return;
+        fs.mkdirSync(this.getBaseDir(), { recursive: true });
+        if (process.platform !== 'win32') {
+            try {
+                fs.chmodSync(this.getBaseDir(), 0o700);
+            }
+            catch { }
+        }
+    }
+    parseCredentials(content) {
+        const profiles = {};
+        const lines = content.split('\n');
+        let currentProfile = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';'))
+                continue;
+            const profileMatch = trimmed.match(/^\[([^\]]+)\]$/);
+            if (profileMatch) {
+                currentProfile = profileMatch[1];
+                profiles[currentProfile] = { apiKey: '' };
+                continue;
+            }
+            if (currentProfile) {
+                const kvMatch = trimmed.match(/^([^=]+)=(.*)$/);
+                if (kvMatch) {
+                    const key = kvMatch[1].trim();
+                    const value = kvMatch[2].trim();
+                    if (key === 'api_key')
+                        profiles[currentProfile].apiKey = value;
+                }
+            }
+        }
+        return profiles;
+    }
+    serializeCredentials(profiles) {
+        const lines = [];
+        const profileEntries = Object.entries(profiles);
+        profileEntries.forEach(([profileName, credentials]) => {
+            lines.push(`[${profileName}]`);
+            lines.push(`api_key=${credentials.apiKey}`);
+            lines.push('');
+        });
+        return lines.join('\n');
+    }
+    readCredentials() {
+        const credentialsPath = this.getCredentialsPath();
+        if (!fs.existsSync(credentialsPath))
+            return {};
+        const content = fs.readFileSync(credentialsPath, 'utf-8');
+        return this.parseCredentials(content);
+    }
+    writeCredentials(profiles) {
+        this.createCredentialsDirIfNotExists();
+        const credentialsPath = this.getCredentialsPath();
+        const content = this.serializeCredentials(profiles);
+        fs.writeFileSync(credentialsPath, content, { mode: 0o600 });
+        if (process.platform !== 'win32') {
+            try {
+                fs.chmodSync(credentialsPath, 0o600);
+            }
+            catch { }
+        }
+    }
+    saveProfile(profileName, apiKey) {
+        const profiles = this.readCredentials();
+        profiles[profileName] = { apiKey };
+        this.writeCredentials(profiles);
+    }
+    getProfile(profileName = DEFAULT_PROFILE) {
+        const credentialsDir = this.getBaseDir();
+        const credentialsPath = this.getCredentialsPath();
+        if (!fs.existsSync(credentialsDir)) {
+            throw new Error(`No credentials directory found at ${credentialsDir}. Run 'mimic login' to authenticate.`);
+        }
+        if (!fs.existsSync(credentialsPath)) {
+            throw new Error(`No credentials file found. Run 'mimic login' to authenticate.`);
+        }
+        const profiles = this.readCredentials();
+        if (!profiles[profileName]) {
+            const availableProfiles = Object.keys(profiles);
+            const suggestion = availableProfiles.length > 0
+                ? `Available profiles: ${availableProfiles.join(', ')}`
+                : `No profiles found. Run 'mimic login' to create one.`;
+            throw new Error(`Profile '${profileName}' not found. ${suggestion}`);
+        }
+        const credentials = profiles[profileName];
+        if (!credentials.apiKey || credentials.apiKey.trim() === '') {
+            throw new Error(`Profile '${profileName}' has no API key. Run 'mimic login --profile ${profileName}' to update credentials.`);
+        }
+        return credentials;
+    }
+    getCredentials(profileName = DEFAULT_PROFILE) {
+        try {
+            return this.getProfile(profileName);
+        }
+        catch (error) {
+            if (error instanceof Error)
+                throw new Error(`Authentication required: ${error.message}`);
+            throw error;
+        }
+    }
+    getProfiles() {
+        const profiles = this.readCredentials();
+        return Object.keys(profiles);
+    }
+    removeProfile(profileName) {
+        const profiles = this.readCredentials();
+        if (!profiles[profileName])
+            throw new Error(`Profile '${profileName}' does not exist`);
+        delete profiles[profileName];
+        this.writeCredentials(profiles);
+    }
+    profileExists(profileName) {
+        const profiles = this.readCredentials();
+        return profileName in profiles;
+    }
+}
+exports.CredentialsManager = CredentialsManager;

package/dist/types.js

@@ -7,9 +7,9 @@ var LibTypes;
     LibTypes["Address"] = "Address";
     LibTypes["Bytes"] = "Bytes";
     LibTypes["ChainId"] = "ChainId";
-    LibTypes["TokenAmount"] = "TokenAmount";
     LibTypes["Void"] = "Void";
     LibTypes["Result"] = "Result";
+    LibTypes["JSON"] = "JSON";
 })(LibTypes || (exports.LibTypes = LibTypes = {}));
 var AssemblyPrimitiveTypes;
 (function (AssemblyPrimitiveTypes) {

package/package.json

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