genlayer 0.38.9 → 0.38.10

package/esbuild.config.js

@@ -0,0 +1,22 @@
+/* eslint-disable no-undef -- Allow process and console in ignored file */
+
+import esbuild from "esbuild";
+
+const isProduction = process.env.NODE_ENV === "production";
+const config = isProduction
+  ? await import("./esbuild.config.prod.js")
+  : await import("./esbuild.config.dev.js");
+
+const run = async () => {
+  if (config.default.watch) {
+    const context = await esbuild.context(config.default.context);
+    await context.watch();
+  } else {
+    await esbuild.build(config.default.context);
+  }
+};
+
+run().catch(e => {
+  console.error(e);
+  process.exit(1);
+});

package/esbuild.config.prod.js

@@ -0,0 +1,17 @@
+export default {
+  context: {
+    tsconfig: "./tsconfig.json",
+    entryPoints: ["src/index.ts"],
+    bundle: true,
+    outfile: "dist/index.js",
+    platform: "node",
+    target: "es2020",
+    format: "esm",
+    define: { "import.meta.url": "import.meta.url" },
+    banner: {
+      js: `const _importMetaUrl = new URL(import.meta.url).pathname;`,
+    },
+    external: ["commander", "dockerode", "dotenv", "ethers", "inquirer", "update-check", "ssh2", "fs-extra", "esbuild", "keytar"]
+  },
+  watch: false,
+};

package/eslint.config.js

@@ -0,0 +1,60 @@
+import js from "@eslint/js";
+import tseslint from "@typescript-eslint/eslint-plugin";
+import tsparser from "@typescript-eslint/parser";
+import prettier from "eslint-config-prettier";
+import importPlugin from "eslint-plugin-import";
+
+export default [
+  js.configs.recommended,
+  prettier,
+  {
+    languageOptions: {
+      parser: tsparser,
+      parserOptions: {
+        project: ["./tsconfig.json"],
+        sourceType: "module",
+      },
+    },
+    ignores: [
+      "**/dist/**/*",
+      "esbuild.config.js",
+      "esbuild.config.dev.js",
+      "esbuild.config.prod.js",
+      "jest.config.js",
+      "eslint.config.js",
+      "Config.js",
+      "commitLint.config.ts",
+      "scripts/postinstall.js",
+      "templates/**/*"
+    ],
+    plugins: {
+      "@typescript-eslint": tseslint,
+      import: importPlugin,
+    },
+    rules: {
+      "import/namespace": "off",
+      "@typescript-eslint/no-empty-function": "off",
+      "@typescript-eslint/no-empty-interface": "off",
+      "no-constant-condition": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "prefer-const": "off",
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/ban-ts-ignore": "off",
+      "@typescript-eslint/no-loss-of-precision": "off",
+      "@typescript-eslint/ban-types": "off",
+      "@typescript-eslint/ban-ts-comment": "off",
+      "@typescript-eslint/no-non-null-asserted-optional-chain": "off",
+      "@typescript-eslint/no-var-requires": "off",
+      "import/export": "off",
+      "no-fallthrough": "off",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/no-floating-promises": ["error"],
+      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+    },
+    settings: {
+      "import/resolver": {
+        typescript: {},
+      },
+    },
+  },
+];

package/package.json

@@ -1,21 +1,12 @@
 {
   "name": "genlayer",
-  "version": "0.38.9",
+  "version": "0.38.10",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",
   "bin": {
     "genlayer": "./dist/index.js"
   },
-  "files": [
-    "dist",
-    "scripts",
-    "templates",
-    ".env.example",
-    "docker-compose.yml",
-    "README.md",
-    "LICENSE"
-  ],
   "scripts": {
     "test": "vitest",
     "test:watch": "vitest --watch",
@@ -76,7 +67,7 @@
     "dotenv": "^17.0.0",
     "ethers": "^6.13.4",
     "fs-extra": "^11.3.0",
-    "genlayer-js": "^0.23.0",
+    "genlayer-js": "^0.27.9",
     "inquirer": "^12.0.0",
     "keytar": "^7.9.0",
     "node-fetch": "^3.0.0",

package/renovate.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ],
+  "ignorePaths": [
+    "templates/**"
+  ],
+  "packageRules": [
+    {
+      "groupName": "all non-major dependencies",
+      "groupSlug": "all-minor-patch",
+      "matchPackageNames": [
+        "*"
+      ],
+      "matchUpdateTypes": [
+        "minor",
+        "patch"
+      ]
+    }
+  ]
+}

package/scripts/generate-cli-docs.mjs

@@ -17,9 +17,44 @@ function toSlug(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
 }
 
+const COMMAND_GROUPS = {
+  'init': 'environment',
+  'up': 'environment',
+  'stop': 'environment',
+  'new': 'environment',
+  'update': 'environment',
+  'config': 'configuration',
+  'network': 'configuration',
+  'deploy': 'contracts',
+  'call': 'contracts',
+  'write': 'contracts',
+  'schema': 'contracts',
+  'code': 'contracts',
+  'receipt': 'transactions',
+  'trace': 'transactions',
+  'appeal': 'transactions',
+  'appeal-bond': 'transactions',
+  'account': 'accounts',
+  'staking': 'staking',
+  'localnet': 'localnet',
+};
+
 function makeCommandFilepath(commandPath) {
   const parts = commandPath.split(' ');
-  if (parts.length === 1) return { relDir: '', filename: `${toSlug(parts[0])}.mdx` };
+  const topCommand = toSlug(parts[0]);
+  const group = COMMAND_GROUPS[topCommand];
+
+  if (parts.length === 1 && group) {
+    return { relDir: group, filename: `${topCommand}.mdx` };
+  }
+  if (parts.length === 1) {
+    return { relDir: '', filename: `${topCommand}.mdx` };
+  }
+  // Subcommands go under group/parent/sub.mdx
+  const parentGroup = COMMAND_GROUPS[topCommand];
+  if (parentGroup) {
+    return { relDir: [parentGroup, topCommand, ...parts.slice(1, -1)].map(toSlug).join('/'), filename: `${toSlug(parts[parts.length - 1])}.mdx` };
+  }
   return { relDir: parts.slice(0, -1).map(toSlug).join('/'), filename: `${toSlug(parts[parts.length - 1])}.mdx` };
 }
 
@@ -246,12 +281,40 @@ async function main() {
 
   const defaultOut = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'docs', 'api-references');
   const rootOut = outputDirFromEnv ? outputDirFromEnv : defaultOut;
-  if (clean) await rmrf(rootOut);
+  await rmrf(rootOut);
   await writePages(rootOut, outputs);
 
-  const meta = {};
-  for (const c of (rootHelp.subcommands || []).map((c) => toSlug(c.name))) meta[c] = c;
-  await fs.writeFile(path.join(rootOut, '_meta.json'), JSON.stringify(meta, null, 2), 'utf8');
+  // Write root _meta.json with groups
+  const GROUP_LABELS = {
+    'environment': 'Environment',
+    'configuration': 'Configuration',
+    'contracts': 'Contracts',
+    'transactions': 'Transactions',
+    'accounts': 'Accounts',
+    'staking': 'Staking',
+    'localnet': 'Localnet',
+  };
+  const rootMeta = {};
+  for (const [key, label] of Object.entries(GROUP_LABELS)) {
+    rootMeta[key] = label;
+  }
+  await fs.writeFile(path.join(rootOut, '_meta.json'), JSON.stringify(rootMeta, null, 2), 'utf8');
+
+  // Write _meta.json for each group subdirectory
+  const groupCommands = {};
+  for (const [cmd, group] of Object.entries(COMMAND_GROUPS)) {
+    if (!groupCommands[group]) groupCommands[group] = [];
+    groupCommands[group].push(cmd);
+  }
+  for (const [group, cmds] of Object.entries(groupCommands)) {
+    const groupDir = path.join(rootOut, group);
+    await ensureDir(groupDir);
+    const groupMeta = {};
+    for (const cmd of cmds) {
+      groupMeta[toSlug(cmd)] = cmd;
+    }
+    await fs.writeFile(path.join(groupDir, '_meta.json'), JSON.stringify(groupMeta, null, 2), 'utf8');
+  }
 
   console.log(`Generated ${outputs.length} pages at ${rootOut}`);
 }

package/src/commands/account/create.ts

@@ -0,0 +1,30 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+
+export interface CreateAccountOptions {
+  name: string;
+  overwrite: boolean;
+  setActive?: boolean;
+  password?: string;
+}
+
+export class CreateAccountAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: CreateAccountOptions): Promise<void> {
+    try {
+      this.startSpinner(`Creating account '${options.name}'...`);
+      await this.createKeypairByName(options.name, options.overwrite, options.password);
+
+      if (options.setActive !== false) {
+        this.setActiveAccount(options.name);
+      }
+
+      const keystorePath = this.getKeystorePath(options.name);
+      this.succeedSpinner(`Account '${options.name}' created at: ${keystorePath}`);
+    } catch (error) {
+      this.failSpinner("Failed to create account", error);
+    }
+  }
+}

package/src/commands/account/export.ts

@@ -0,0 +1,106 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {ethers} from "ethers";
+import {writeFileSync, existsSync, readFileSync} from "fs";
+import path from "path";
+
+export interface ExportAccountOptions {
+  account?: string;
+  output: string;
+  password?: string;
+  sourcePassword?: string;
+  overwrite?: boolean;
+}
+
+export class ExportAccountAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ExportAccountOptions): Promise<void> {
+    try {
+      if (options.account) {
+        this.accountOverride = options.account;
+      }
+
+      const accountName = this.resolveAccountName();
+      const keystorePath = this.getKeystorePath(accountName);
+
+      if (!existsSync(keystorePath)) {
+        this.failSpinner(`Account '${accountName}' not found.`);
+      }
+
+      const outputPath = path.resolve(options.output);
+
+      if (existsSync(outputPath) && !options.overwrite) {
+        this.failSpinner(`Output file already exists: ${outputPath}`);
+      }
+
+      // Get the private key
+      const privateKey = await this.getPrivateKeyForExport(accountName, keystorePath, options.sourcePassword);
+
+      // Get password for the exported keystore
+      let password: string;
+      if (options.password) {
+        password = options.password;
+      } else {
+        password = await this.promptPassword("Enter password for exported keystore (minimum 8 characters):");
+        const confirmPassword = await this.promptPassword("Confirm password:");
+        if (password !== confirmPassword) {
+          this.failSpinner("Passwords do not match");
+        }
+      }
+
+      if (password.length < BaseAction.MIN_PASSWORD_LENGTH) {
+        this.failSpinner(`Password must be at least ${BaseAction.MIN_PASSWORD_LENGTH} characters long`);
+      }
+
+      this.startSpinner(`Exporting account '${accountName}'...`);
+
+      const wallet = new ethers.Wallet(privateKey);
+      const encryptedJson = await wallet.encrypt(password);
+
+      // Write standard web3 keystore format (compatible with geth, foundry, etc.)
+      writeFileSync(outputPath, encryptedJson);
+
+      this.succeedSpinner(`Account '${accountName}' exported to: ${outputPath}`);
+      this.logInfo(`Address: ${wallet.address}`);
+    } catch (error) {
+      this.failSpinner("Failed to export account", error);
+    }
+  }
+
+  private async getPrivateKeyForExport(
+    accountName: string,
+    keystorePath: string,
+    sourcePassword?: string
+  ): Promise<string> {
+    // First check if key is cached in keychain
+    const isAvailable = await this.keychainManager.isKeychainAvailable();
+    if (isAvailable) {
+      const cachedKey = await this.keychainManager.getPrivateKey(accountName);
+      if (cachedKey) {
+        return cachedKey;
+      }
+    }
+
+    // Need to decrypt the keystore
+    const fileContent = readFileSync(keystorePath, "utf-8");
+    const parsed = JSON.parse(fileContent);
+
+    const encryptedJson = parsed.encrypted || fileContent;
+
+    const password = sourcePassword || await this.promptPassword(`Enter password to unlock '${accountName}':`);
+
+    this.startSpinner("Decrypting keystore...");
+
+    try {
+      const wallet = await ethers.Wallet.fromEncryptedJson(encryptedJson, password);
+      this.stopSpinner();
+      return wallet.privateKey;
+    } catch {
+      this.failSpinner("Failed to decrypt keystore. Wrong password?");
+    }
+
+    throw new Error("Unreachable");
+  }
+}

package/src/commands/account/import.ts

@@ -0,0 +1,135 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {ethers} from "ethers";
+import {writeFileSync, existsSync, readFileSync} from "fs";
+
+export interface ImportAccountOptions {
+  privateKey?: string;
+  keystore?: string;
+  name: string;
+  overwrite: boolean;
+  setActive?: boolean;
+  password?: string;
+  sourcePassword?: string;
+}
+
+export class ImportAccountAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ImportAccountOptions): Promise<void> {
+    try {
+      const keystorePath = this.getKeystorePath(options.name);
+
+      if (existsSync(keystorePath) && !options.overwrite) {
+        this.failSpinner(`Account '${options.name}' already exists. Use '--overwrite' to replace.`);
+      }
+
+      let privateKey: string;
+
+      if (options.keystore) {
+        privateKey = await this.importFromKeystore(options.keystore, options.sourcePassword);
+      } else if (options.privateKey) {
+        const normalizedKey = this.normalizePrivateKey(options.privateKey);
+        this.validatePrivateKey(normalizedKey);
+        privateKey = normalizedKey;
+      } else {
+        const inputKey = await this.promptPrivateKey();
+        const normalizedKey = this.normalizePrivateKey(inputKey);
+        this.validatePrivateKey(normalizedKey);
+        privateKey = normalizedKey;
+      }
+
+      const wallet = new ethers.Wallet(privateKey);
+
+      let password: string;
+      if (options.password) {
+        password = options.password;
+      } else {
+        password = await this.promptPassword("Enter a password to encrypt your keystore (minimum 8 characters):");
+        const confirmPassword = await this.promptPassword("Confirm password:");
+        if (password !== confirmPassword) {
+          this.failSpinner("Passwords do not match");
+        }
+      }
+
+      if (password.length < BaseAction.MIN_PASSWORD_LENGTH) {
+        this.failSpinner(`Password must be at least ${BaseAction.MIN_PASSWORD_LENGTH} characters long`);
+      }
+
+      this.startSpinner(`Importing account '${options.name}'...`);
+
+      const encryptedJson = await wallet.encrypt(password);
+
+      // Write standard web3 keystore format directly
+      writeFileSync(keystorePath, encryptedJson);
+
+      if (options.setActive !== false) {
+        this.setActiveAccount(options.name);
+      }
+
+      await this.keychainManager.removePrivateKey(options.name);
+
+      this.succeedSpinner(`Account '${options.name}' imported to: ${keystorePath}`);
+      this.logInfo(`Address: ${wallet.address}`);
+    } catch (error) {
+      this.failSpinner("Failed to import account", error);
+    }
+  }
+
+  private async importFromKeystore(keystorePath: string, sourcePassword?: string): Promise<string> {
+    if (!existsSync(keystorePath)) {
+      this.failSpinner(`Keystore file not found: ${keystorePath}`);
+    }
+
+    const fileContent = readFileSync(keystorePath, "utf-8");
+    let encryptedJson: string;
+
+    try {
+      const parsed = JSON.parse(fileContent);
+
+      // Check if it's our format (with 'encrypted' field) or standard web3 keystore
+      if (parsed.encrypted) {
+        // Our format
+        encryptedJson = parsed.encrypted;
+      } else if (parsed.crypto || parsed.Crypto) {
+        // Standard web3 keystore format (geth, foundry, etc.)
+        encryptedJson = fileContent;
+      } else {
+        this.failSpinner("Invalid keystore format. Expected encrypted keystore file.");
+      }
+    } catch {
+      this.failSpinner("Invalid keystore file. Could not parse JSON.");
+    }
+
+    const password = sourcePassword || await this.promptPassword("Enter password to decrypt keystore:");
+
+    this.startSpinner("Decrypting keystore...");
+
+    try {
+      const wallet = await ethers.Wallet.fromEncryptedJson(encryptedJson!, password);
+      this.stopSpinner();
+      return wallet.privateKey;
+    } catch {
+      this.failSpinner("Failed to decrypt keystore. Wrong password?");
+    }
+
+    // This line is unreachable but TypeScript needs it
+    throw new Error("Unreachable");
+  }
+
+  private async promptPrivateKey(): Promise<string> {
+    return this.promptPassword("Enter private key to import:");
+  }
+
+  private normalizePrivateKey(key: string): string {
+    const trimmed = key.trim();
+    return trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+  }
+
+  private validatePrivateKey(key: string): void {
+    if (!/^0x[0-9a-fA-F]{64}$/.test(key)) {
+      this.failSpinner("Invalid private key format. Expected 64 hex characters (with or without 0x prefix).");
+    }
+  }
+}

package/src/commands/account/index.ts

@@ -0,0 +1,129 @@
+import {Command} from "commander";
+import {ShowAccountAction, ShowAccountOptions} from "./show";
+import {CreateAccountAction, CreateAccountOptions} from "./create";
+import {ImportAccountAction, ImportAccountOptions} from "./import";
+import {ExportAccountAction, ExportAccountOptions} from "./export";
+import {UnlockAccountAction, UnlockAccountOptions} from "./unlock";
+import {LockAccountAction, LockAccountOptions} from "./lock";
+import {SendAction, SendOptions} from "./send";
+import {ListAccountsAction} from "./list";
+import {UseAccountAction} from "./use";
+import {RemoveAccountAction} from "./remove";
+
+export function initializeAccountCommands(program: Command) {
+  const accountCommand = program
+    .command("account")
+    .description("Manage your accounts (address, balance, keys)")
+    .action(async () => {
+      // Default action: show account info (use 'account show' for options)
+      const showAction = new ShowAccountAction();
+      await showAction.execute({});
+    });
+
+  accountCommand
+    .command("list")
+    .description("List all accounts")
+    .action(async () => {
+      const listAction = new ListAccountsAction();
+      await listAction.execute();
+    });
+
+  accountCommand
+    .command("show")
+    .description("Show account details (address, balance)")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .option("--account <name>", "Account to show")
+    .action(async (options: ShowAccountOptions) => {
+      const showAction = new ShowAccountAction();
+      await showAction.execute(options);
+    });
+
+  accountCommand
+    .command("create")
+    .description("Create a new account with encrypted keystore")
+    .requiredOption("--name <name>", "Name for the account")
+    .option("--password <password>", "Password for the keystore (skips interactive prompt)")
+    .option("--overwrite", "Overwrite existing account", false)
+    .option("--no-set-active", "Do not set as active account")
+    .action(async (options: CreateAccountOptions) => {
+      const createAction = new CreateAccountAction();
+      await createAction.execute(options);
+    });
+
+  accountCommand
+    .command("import")
+    .description("Import an account from a private key or keystore file")
+    .requiredOption("--name <name>", "Name for the account")
+    .option("--private-key <key>", "Private key to import")
+    .option("--keystore <path>", "Path to keystore file to import (geth, foundry, etc.)")
+    .option("--password <password>", "Password for the new keystore (skips confirmation prompt)")
+    .option("--source-password <password>", "Password to decrypt source keystore (with --keystore)")
+    .option("--overwrite", "Overwrite existing account", false)
+    .option("--no-set-active", "Do not set as active account")
+    .action(async (options: ImportAccountOptions) => {
+      const importAction = new ImportAccountAction();
+      await importAction.execute(options);
+    });
+
+  accountCommand
+    .command("export")
+    .description("Export an account to a keystore file (web3/geth/foundry compatible)")
+    .requiredOption("--output <path>", "Output path for the keystore file")
+    .option("--account <name>", "Account to export (defaults to active account)")
+    .option("--password <password>", "Password for exported keystore (skips confirmation)")
+    .option("--source-password <password>", "Password to decrypt account (if not unlocked)")
+    .action(async (options: ExportAccountOptions) => {
+      const exportAction = new ExportAccountAction();
+      await exportAction.execute(options);
+    });
+
+  accountCommand
+    .command("use <name>")
+    .description("Set the active account")
+    .action(async (name: string) => {
+      const useAction = new UseAccountAction();
+      await useAction.execute(name);
+    });
+
+  accountCommand
+    .command("remove <name>")
+    .description("Remove an account")
+    .option("--force", "Skip confirmation prompt", false)
+    .action(async (name: string, options: {force?: boolean}) => {
+      const removeAction = new RemoveAccountAction();
+      await removeAction.execute(name, options);
+    });
+
+  accountCommand
+    .command("send <to> <amount>")
+    .description("Send GEN to an address")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .option("--network <network>", "Network to use (localnet, testnet-asimov)")
+    .option("--account <name>", "Account to send from")
+    .option("--password <password>", "Password to unlock account (skips interactive prompt)")
+    .action(async (to: string, amount: string, options: {rpc?: string; network?: string; account?: string; password?: string}) => {
+      const sendAction = new SendAction();
+      await sendAction.execute({to, amount, rpc: options.rpc, network: options.network, account: options.account, password: options.password});
+    });
+
+  accountCommand
+    .command("unlock")
+    .description("Unlock account by caching private key in OS keychain")
+    .option("--account <name>", "Account to unlock")
+    .option("--password <password>", "Password to unlock account (skips interactive prompt)")
+    .action(async (options: UnlockAccountOptions) => {
+      const unlockAction = new UnlockAccountAction();
+      await unlockAction.execute(options);
+    });
+
+  accountCommand
+    .command("lock")
+    .description("Lock account by removing private key from OS keychain")
+    .option("--account <name>", "Account to lock")
+    .action(async (options: LockAccountOptions) => {
+      const lockAction = new LockAccountAction();
+      await lockAction.execute(options);
+    });
+
+  return program;
+}

package/src/commands/account/list.ts

@@ -0,0 +1,34 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+
+export class ListAccountsAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async execute(): Promise<void> {
+    try {
+      const accounts = this.listAccounts();
+      const activeAccount = this.getActiveAccount();
+      const unlockedAccounts = await this.keychainManager.listUnlockedAccounts();
+
+      if (accounts.length === 0) {
+        this.logInfo("No accounts found. Run 'genlayer account create --name <name>' to create one.");
+        return;
+      }
+
+      console.log("");
+      for (const account of accounts) {
+        const isActive = account.name === activeAccount;
+        const isUnlocked = unlockedAccounts.includes(account.name);
+        const marker = isActive ? "*" : " ";
+        const status = isUnlocked ? "(unlocked)" : "";
+        const activeLabel = isActive ? "(active)" : "";
+
+        console.log(`${marker} ${account.name.padEnd(16)} ${account.address} ${activeLabel} ${status}`.trim());
+      }
+      console.log("");
+    } catch (error) {
+      this.failSpinner("Failed to list accounts", error);
+    }
+  }
+}