genlayer 0.31.0 → 0.32.1

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,126 @@
+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("--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")
+    .action(async (to: string, amount: string, options: {rpc?: string; network?: string; account?: string}) => {
+      const sendAction = new SendAction();
+      await sendAction.execute({to, amount, rpc: options.rpc, network: options.network, account: options.account});
+    });
+
+  accountCommand
+    .command("unlock")
+    .description("Unlock account by caching private key in OS keychain")
+    .option("--account <name>", "Account to unlock")
+    .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);
+    }
+  }
+}

package/src/commands/account/lock.ts

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

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

package/src/commands/account/send.ts

@@ -0,0 +1,156 @@
+import {BaseAction, BUILT_IN_NETWORKS, resolveNetwork} from "../../lib/actions/BaseAction";
+import {parseEther, formatEther} from "viem";
+import {createClient, createAccount} from "genlayer-js";
+import type {GenLayerChain, Address, Hash} from "genlayer-js/types";
+import {readFileSync, existsSync} from "fs";
+import {ethers} from "ethers";
+
+export interface SendOptions {
+  to: string;
+  amount: string;
+  rpc?: string;
+  network?: string;
+  account?: string;
+}
+
+export class SendAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  private getNetwork(networkOption?: string): GenLayerChain {
+    if (networkOption) {
+      const network = BUILT_IN_NETWORKS[networkOption];
+      if (!network) {
+        throw new Error(`Unknown network: ${networkOption}. Available: ${Object.keys(BUILT_IN_NETWORKS).join(", ")}`);
+      }
+      return network;
+    }
+    return resolveNetwork(this.getConfig().network);
+  }
+
+  private parseAmount(amount: string): bigint {
+    // Support "10gen" or "10" (assumes gen) or wei values
+    const lowerAmount = amount.toLowerCase();
+    if (lowerAmount.endsWith("gen")) {
+      const value = lowerAmount.slice(0, -3);
+      return parseEther(value);
+    }
+    // If it's a large number (likely wei), use as-is
+    if (BigInt(amount) > 1_000_000_000_000n) {
+      return BigInt(amount);
+    }
+    // Otherwise assume it's in GEN
+    return parseEther(amount);
+  }
+
+  async execute(options: SendOptions): Promise<void> {
+    this.startSpinner("Preparing transfer...");
+
+    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. Run 'genlayer account create --name ${accountName}' first.`);
+        return;
+      }
+
+      const keystoreJson = readFileSync(keystorePath, "utf-8");
+      const keystoreData = JSON.parse(keystoreJson);
+
+      if (!this.isValidKeystoreFormat(keystoreData)) {
+        this.failSpinner("Invalid keystore format.");
+        return;
+      }
+
+      // Get private key
+      const cachedKey = await this.keychainManager.getPrivateKey(accountName);
+      let privateKey: string;
+
+      if (cachedKey) {
+        privateKey = cachedKey;
+      } else {
+        this.stopSpinner();
+        const password = await this.promptPassword(`Enter password to unlock account '${accountName}':`);
+        this.startSpinner("Preparing transfer...");
+        const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
+        privateKey = wallet.privateKey;
+      }
+
+      const network = this.getNetwork(options.network);
+      const account = createAccount(privateKey as Hash);
+      const amount = this.parseAmount(options.amount);
+
+      const client = createClient({
+        chain: network,
+        account,
+        endpoint: options.rpc,
+      });
+
+      this.setSpinnerText(`Sending ${formatEther(amount)} GEN to ${options.to}...`);
+
+      // Get nonce
+      const nonce = await client.getCurrentNonce({address: account.address});
+
+      // Prepare and sign transaction (let prepareTransactionRequest estimate gas)
+      const transactionRequest = await client.prepareTransactionRequest({
+        account,
+        to: options.to as Address,
+        value: amount,
+        type: "legacy",
+        nonce: Number(nonce),
+      });
+
+      const serializedTransaction = await account.signTransaction(transactionRequest);
+      const txHash = await client.sendRawTransaction({serializedTransaction});
+
+      this.setSpinnerText(`Transaction submitted: ${txHash}\nWaiting for confirmation...`);
+
+      // Poll for receipt (standard ETH transfer, not GenVM tx)
+      let receipt = null;
+      for (let i = 0; i < 60; i++) {
+        try {
+          receipt = await client.getTransactionReceipt({hash: txHash});
+          if (receipt) break;
+        } catch {
+          // Receipt not available yet, continue polling
+        }
+        await new Promise((r) => setTimeout(r, 2000));
+      }
+
+      if (!receipt) {
+        // Tx submitted but receipt not found yet - still success
+        this.succeedSpinner("Transfer submitted (pending confirmation)", {
+          transactionHash: txHash,
+          from: account.address,
+          to: options.to,
+          amount: `${formatEther(amount)} GEN`,
+        });
+        return;
+      }
+
+      if (receipt.status === "reverted") {
+        this.failSpinner("Transaction reverted");
+        return;
+      }
+
+      const result = {
+        transactionHash: txHash,
+        from: account.address,
+        to: options.to,
+        amount: `${formatEther(amount)} GEN`,
+        blockNumber: receipt.blockNumber.toString(),
+        gasUsed: receipt.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Transfer successful!", result);
+    } catch (error: any) {
+      this.failSpinner("Transfer failed", error.message || error);
+    }
+  }
+}

package/src/commands/account/show.ts

@@ -0,0 +1,74 @@
+import {BaseAction, resolveNetwork} from "../../lib/actions/BaseAction";
+import {formatEther} from "viem";
+import {createClient} from "genlayer-js";
+import type {GenLayerChain, Address} from "genlayer-js/types";
+import {readFileSync, existsSync} from "fs";
+
+export interface ShowAccountOptions {
+  rpc?: string;
+  account?: string;
+}
+
+export class ShowAccountAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  private getNetwork(): GenLayerChain {
+    return resolveNetwork(this.getConfig().network);
+  }
+
+  async execute(options?: ShowAccountOptions): Promise<void> {
+    this.startSpinner("Fetching account info...");
+
+    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. Run 'genlayer account create --name ${accountName}' first.`);
+        return;
+      }
+
+      const keystoreData = JSON.parse(readFileSync(keystorePath, "utf-8"));
+
+      if (!this.isValidKeystoreFormat(keystoreData)) {
+        this.failSpinner("Invalid keystore format.");
+        return;
+      }
+
+      const rawAddr = keystoreData.address;
+      const address = (rawAddr.startsWith("0x") ? rawAddr : `0x${rawAddr}`) as Address;
+      const network = this.getNetwork();
+
+      const client = createClient({
+        chain: network,
+        account: address,
+        endpoint: options?.rpc,
+      });
+
+      const balance = await client.getBalance({address});
+      const formattedBalance = formatEther(balance);
+
+      const isUnlocked = await this.keychainManager.isAccountUnlocked(accountName);
+      const isActive = this.getActiveAccount() === accountName;
+
+      const result = {
+        name: accountName,
+        address,
+        balance: `${formattedBalance} GEN`,
+        network: network.name || "localnet",
+        status: isUnlocked ? "unlocked" : "locked",
+        active: isActive,
+      };
+
+      this.succeedSpinner("Account info", result);
+    } catch (error: any) {
+      this.failSpinner("Failed to get account info", error.message || error);
+    }
+  }
+}

package/src/commands/account/unlock.ts

@@ -0,0 +1,51 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {readFileSync, existsSync} from "fs";
+import {ethers} from "ethers";
+
+export interface UnlockAccountOptions {
+  account?: string;
+}
+
+export class UnlockAccountAction extends BaseAction {
+  async execute(options?: UnlockAccountOptions): 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 account '${accountName}'...`);
+
+    const keystorePath = this.getKeystorePath(accountName);
+    if (!existsSync(keystorePath)) {
+      this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
+      return;
+    }
+
+    const keystoreJson = readFileSync(keystorePath, "utf-8");
+    const keystoreData = JSON.parse(keystoreJson);
+    if (!this.isValidKeystoreFormat(keystoreData)) {
+      this.failSpinner("Invalid keystore format.");
+      return;
+    }
+
+    this.stopSpinner();
+
+    try {
+      const password = await this.promptPassword(`Enter password to unlock '${accountName}':`);
+      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
+
+      await this.keychainManager.storePrivateKey(accountName, wallet.privateKey);
+      this.succeedSpinner(`Account '${accountName}' unlocked! Private key cached in OS keychain.`);
+    } catch (error) {
+      this.failSpinner("Failed to unlock account.", error);
+    }
+  }
+}

package/src/commands/account/use.ts

@@ -0,0 +1,21 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+
+export class UseAccountAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async execute(name: string): Promise<void> {
+    try {
+      if (!this.accountExists(name)) {
+        this.failSpinner(`Account '${name}' does not exist. Run 'genlayer account list' to see available accounts.`);
+        return;
+      }
+
+      this.setActiveAccount(name);
+      this.logSuccess(`Active account set to '${name}'`);
+    } catch (error) {
+      this.failSpinner("Failed to set active account", error);
+    }
+  }
+}