genlayer 0.32.0 → 0.32.2

package/docs/delegator-guide.md

@@ -51,7 +51,7 @@ genlayer staking active-validators
 ```
 
 Output:
-```
+```json
 {
   count: 6,
   validators: [
@@ -94,11 +94,11 @@ Options:
 ## Step 8: Verify Your Delegation
 
 ```bash
-genlayer staking stake-info --validator 0xa8f1...130
+genlayer staking delegation-info --validator 0xa8f1...130
 ```
 
 Output:
-```
+```json
 {
   delegator: '0x86D0d159483CBf01E920ECfF8bB7F0Cd7E964E7E',
   validator: '0xa8f1BF1e5e709593b4468d7ac5DC315Ea3CAe130',
@@ -117,7 +117,7 @@ The `projectedReward` shows your estimated earnings per epoch based on current i
 ### Check Your Stake
 
 ```bash
-genlayer staking stake-info --validator 0xa8f1...130
+genlayer staking delegation-info --validator 0xa8f1...130
 ```
 
 ### Withdraw (Exit) Delegation
@@ -134,8 +134,8 @@ Options:
 
 This initiates a withdrawal. Your tokens enter an **unbonding period of 7 epochs** before they can be claimed.
 
-Check your pending withdrawals with `stake-info`:
-```
+Check your pending withdrawals with `delegation-info`:
+```json
 pendingWithdrawals: [
   {
     epoch: '5',

package/docs/validator-guide.md

@@ -2,33 +2,62 @@
 
 This guide walks you through becoming a validator on the GenLayer testnet using the CLI.
 
+For a deeper understanding of how staking works in GenLayer, see the [Staking documentation](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking).
+
 ## Prerequisites
 
 - Node.js installed
 - GenLayer CLI installed (`npm install -g genlayer`)
 - GEN tokens for staking (minimum stake required)
 
-## Step 1: Create an Account
+## Quick Start: Validator Wizard
+
+The easiest way to become a validator is using the interactive wizard:
+
+```bash
+genlayer staking wizard
+```
+
+The wizard guides you through all steps:
+1. Account setup (create or select)
+2. Network selection
+3. Balance verification
+4. Operator setup (optional, recommended for security)
+5. Stake amount selection
+6. Validator creation
+7. Identity setup (moniker, website, etc.)
+
+If you prefer manual setup, follow the steps below.
+
+---
+
+## Manual Setup
+
+## Step 1: Create an Owner Account
 
 ```bash
-genlayer account create
+genlayer account create --name owner
 ```
 
-You'll be prompted to set a password. This creates an encrypted keystore file.
+You'll be prompted to set a password. This creates an encrypted keystore file in standard web3 format.
+
+The owner account holds your staked funds and controls the validator. Keep it secure.
 
 ## Step 2: View Your Account
 
 ```bash
-genlayer account
+genlayer account show
 ```
 
 Output:
 ```
 {
+  name: 'owner',
   address: '0x86D0d159483CBf01E920ECfF8bB7F0Cd7E964E7E',
   balance: '0 GEN',
   network: 'localnet',
-  status: 'locked'
+  status: 'locked',
+  active: true
 }
 ```
 
@@ -40,19 +69,16 @@ genlayer network testnet-asimov
 
 Verify with:
 ```bash
-genlayer account
+genlayer account show
 ```
 
 You should see `network: 'Asimov Testnet'`.
 
 ## Step 4: Fund Your Account
 
-Transfer GEN tokens to your address. You can:
+Transfer GEN tokens to your address:
 - Use the faucet (if available)
-- Transfer from another account:
-  ```bash
-  genlayer account send <your-address> 50000gen
-  ```
+- Transfer from another funded account using `genlayer account send`
 
 ## Step 5: Check Staking Requirements
 
@@ -108,18 +134,25 @@ Options:
 
 This way, if your operator server is compromised, your staked funds remain safe.
 
+If you already have an operator wallet (e.g., from geth, foundry, or another tool), you can use its address directly. Otherwise, create one:
+
 ```bash
-# Create operator account on your validator server
-genlayer account create --output ./operator.json
+# Create operator account (skip if you already have one)
+genlayer account create --name operator
+
+# View operator address
+genlayer account show --account operator
+# Address: 0xOperator123...
 
-# Get operator address
-cat ./operator.json | jq -r .address
-# 0xOperator123...
+# Export keystore for validator node software (standard web3 format)
+genlayer account export --account operator --output ./operator-keystore.json
 
-# Join with separate operator (run from your main wallet)
+# Join as validator with separate operator
 genlayer staking validator-join --amount 42000gen --operator 0xOperator123...
 ```
 
+Transfer `operator-keystore.json` to your validator server and import it into your validator node software. The keystore is in standard web3 format, compatible with geth, foundry, and other Ethereum tools.
+
 You can change the operator later:
 
 ```bash
@@ -240,7 +273,7 @@ genlayer staking validator-claim
 Run `genlayer account create` first.
 
 ### "Insufficient balance"
-Ensure you have enough GEN. Check with `genlayer account`.
+Ensure you have enough GEN. Check with `genlayer account show`.
 
 ### "Below minimum stake"
 Check minimum with `genlayer staking epoch-info` and increase your stake amount.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.32.0",
+  "version": "0.32.2",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",
@@ -65,7 +65,7 @@
     "dotenv": "^17.0.0",
     "ethers": "^6.13.4",
     "fs-extra": "^11.3.0",
-    "genlayer-js": "^0.18.5",
+    "genlayer-js": "^0.18.7",
     "inquirer": "^12.0.0",
     "keytar": "^7.9.0",
     "node-fetch": "^3.0.0",

package/src/commands/account/create.ts

@@ -1,8 +1,9 @@
 import {BaseAction} from "../../lib/actions/BaseAction";
 
 export interface CreateAccountOptions {
-  output: string;
+  name: string;
   overwrite: boolean;
+  setActive?: boolean;
 }
 
 export class CreateAccountAction extends BaseAction {
@@ -12,10 +13,15 @@ export class CreateAccountAction extends BaseAction {
 
   async execute(options: CreateAccountOptions): Promise<void> {
     try {
-      this.startSpinner("Creating encrypted keystore...");
-      await this.createKeypair(options.output, options.overwrite);
+      this.startSpinner(`Creating account '${options.name}'...`);
+      await this.createKeypairByName(options.name, options.overwrite);
 
-      this.succeedSpinner(`Account created and saved to: ${options.output}`);
+      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

@@ -1,69 +1,123 @@
 import {BaseAction} from "../../lib/actions/BaseAction";
 import {ethers} from "ethers";
-import {writeFileSync, existsSync} from "fs";
-import {KeystoreData} from "../../lib/interfaces/KeystoreData";
+import {writeFileSync, existsSync, readFileSync} from "fs";
 
 export interface ImportAccountOptions {
   privateKey?: string;
-  output: string;
+  keystore?: string;
+  name: string;
   overwrite: boolean;
+  setActive?: boolean;
+  password?: string;
+  sourcePassword?: string;
 }
 
 export class ImportAccountAction extends BaseAction {
-  private static readonly MIN_PASSWORD_LENGTH = 8;
-
   constructor() {
     super();
   }
 
   async execute(options: ImportAccountOptions): Promise<void> {
     try {
-      const privateKey = options.privateKey || await this.promptPrivateKey();
-
-      const normalizedKey = this.normalizePrivateKey(privateKey);
-      this.validatePrivateKey(normalizedKey);
-
-      const finalOutputPath = this.getFilePath(options.output);
+      const keystorePath = this.getKeystorePath(options.name);
 
-      if (existsSync(finalOutputPath) && !options.overwrite) {
-        this.failSpinner(`File at ${finalOutputPath} already exists. Use '--overwrite' to replace.`);
+      if (existsSync(keystorePath) && !options.overwrite) {
+        this.failSpinner(`Account '${options.name}' already exists. Use '--overwrite' to replace.`);
       }
 
-      const wallet = new ethers.Wallet(normalizedKey);
-
-      const password = await this.promptPassword("Enter a password to encrypt your keystore (minimum 8 characters):");
-      const confirmPassword = await this.promptPassword("Confirm password:");
+      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;
+      }
 
-      if (password !== confirmPassword) {
-        this.failSpinner("Passwords do not match");
+      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 < ImportAccountAction.MIN_PASSWORD_LENGTH) {
-        this.failSpinner(`Password must be at least ${ImportAccountAction.MIN_PASSWORD_LENGTH} characters long`);
+      if (password.length < BaseAction.MIN_PASSWORD_LENGTH) {
+        this.failSpinner(`Password must be at least ${BaseAction.MIN_PASSWORD_LENGTH} characters long`);
       }
 
-      this.startSpinner("Encrypting and saving keystore...");
+      this.startSpinner(`Importing account '${options.name}'...`);
 
       const encryptedJson = await wallet.encrypt(password);
 
-      const keystoreData: KeystoreData = {
-        version: 1,
-        encrypted: encryptedJson,
-        address: wallet.address,
-      };
+      // Write standard web3 keystore format directly
+      writeFileSync(keystorePath, encryptedJson);
 
-      writeFileSync(finalOutputPath, JSON.stringify(keystoreData, null, 2));
-      this.writeConfig("keyPairPath", finalOutputPath);
+      if (options.setActive !== false) {
+        this.setActiveAccount(options.name);
+      }
 
-      await this.keychainManager.removePrivateKey();
+      await this.keychainManager.removePrivateKey(options.name);
 
-      this.succeedSpinner(`Account imported and saved to: ${finalOutputPath}`);
+      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:");
   }

package/src/commands/account/index.ts

@@ -1,26 +1,49 @@
 import {Command} from "commander";
-import {ShowAccountAction} from "./show";
+import {ShowAccountAction, ShowAccountOptions} from "./show";
 import {CreateAccountAction, CreateAccountOptions} from "./create";
 import {ImportAccountAction, ImportAccountOptions} from "./import";
-import {UnlockAccountAction} from "./unlock";
-import {LockAccountAction} from "./lock";
+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 account (address, balance, keys)")
+    .description("Manage your accounts (address, balance, keys)")
     .action(async () => {
-      // Default action: show account info
+      // Default action: show account info (use 'account show' for options)
       const showAction = new ShowAccountAction();
-      await showAction.execute();
+      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")
-    .option("--output <path>", "Path to save the keystore", "./keypair.json")
-    .option("--overwrite", "Overwrite existing file", false)
+    .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);
@@ -28,39 +51,75 @@ export function initializeAccountCommands(program: Command) {
 
   accountCommand
     .command("import")
-    .description("Import an account from a private key")
-    .option("--private-key <key>", "Private key to import (will prompt if not provided)")
-    .option("--output <path>", "Path to save the keystore", "./keypair.json")
-    .option("--overwrite", "Overwrite existing file", false)
+    .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)")
-    .action(async (to: string, amount: string, options: {rpc?: string; network?: string}) => {
+    .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});
+      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")
-    .action(async () => {
+    .option("--account <name>", "Account to unlock")
+    .action(async (options: UnlockAccountOptions) => {
       const unlockAction = new UnlockAccountAction();
-      await unlockAction.execute();
+      await unlockAction.execute(options);
     });
 
   accountCommand
     .command("lock")
     .description("Lock account by removing private key from OS keychain")
-    .action(async () => {
+    .option("--account <name>", "Account to lock")
+    .action(async (options: LockAccountOptions) => {
       const lockAction = new LockAccountAction();
-      await lockAction.execute();
+      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);
+    }
+  }
+}