genlayer 0.34.0 → 0.34.3

package/esbuild.config.prod.js

@@ -1,17 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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/renovate.json

@@ -1,22 +0,0 @@
-{
-  "$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/src/commands/account/create.ts

@@ -1,30 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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);
-    }
-  }
-}

package/src/commands/account/lock.ts

@@ -1,39 +0,0 @@
-import {BaseAction} from "../../lib/actions/BaseAction";
-
-export interface LockAccountOptions {
-  account?: string;
-}
-
-export class LockAccountAction extends BaseAction {
-  async execute(options?: LockAccountOptions): Promise<void> {
-    this.startSpinner("Checking keychain availability...");
-
-    const keychainAvailable = await this.keychainManager.isKeychainAvailable();
-    if (!keychainAvailable) {
-      this.failSpinner("OS keychain is not available. This command requires a supported keychain (e.g. macOS Keychain, Windows Credential Manager, or GNOME Keyring).");
-      return;
-    }
-
-    if (options?.account) {
-      this.accountOverride = options.account;
-    }
-
-    const accountName = this.resolveAccountName();
-    this.setSpinnerText(`Checking for cached private key for '${accountName}'...`);
-
-    const hasCachedKey = await this.keychainManager.getPrivateKey(accountName);
-    if (!hasCachedKey) {
-      this.succeedSpinner(`Account '${accountName}' is already locked.`);
-      return;
-    }
-
-    this.setSpinnerText(`Removing private key for '${accountName}' from OS keychain...`);
-
-    try {
-      await this.keychainManager.removePrivateKey(accountName);
-      this.succeedSpinner(`Account '${accountName}' locked! Private key removed from OS keychain.`);
-    } catch (error) {
-      this.failSpinner("Failed to lock account.", error);
-    }
-  }
-}

package/src/commands/account/remove.ts

@@ -1,30 +0,0 @@
-import {BaseAction} from "../../lib/actions/BaseAction";
-
-export class RemoveAccountAction extends BaseAction {
-  constructor() {
-    super();
-  }
-
-  async execute(name: string, options: {force?: boolean}): Promise<void> {
-    try {
-      if (!this.accountExists(name)) {
-        this.failSpinner(`Account '${name}' does not exist.`);
-        return;
-      }
-
-      if (!options.force) {
-        await this.confirmPrompt(`Are you sure you want to remove account '${name}'? This cannot be undone.`);
-      }
-
-      // Remove from keychain if unlocked
-      await this.keychainManager.removePrivateKey(name);
-
-      // Remove keystore file
-      this.removeAccount(name);
-
-      this.logSuccess(`Account '${name}' removed`);
-    } catch (error) {
-      this.failSpinner("Failed to remove account", error);
-    }
-  }
-}