genlayer 0.32.0 → 0.32.2

package/src/commands/account/lock.ts

@@ -1,7 +1,11 @@
 import {BaseAction} from "../../lib/actions/BaseAction";
 
+export interface LockAccountOptions {
+  account?: string;
+}
+
 export class LockAccountAction extends BaseAction {
-  async execute(): Promise<void> {
+  async execute(options?: LockAccountOptions): Promise<void> {
     this.startSpinner("Checking keychain availability...");
 
     const keychainAvailable = await this.keychainManager.isKeychainAvailable();
@@ -10,19 +14,24 @@ export class LockAccountAction extends BaseAction {
       return;
     }
 
-    this.setSpinnerText("Checking for cached private key...");
+    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();
+    const hasCachedKey = await this.keychainManager.getPrivateKey(accountName);
     if (!hasCachedKey) {
-      this.succeedSpinner("Account is already locked.");
+      this.succeedSpinner(`Account '${accountName}' is already locked.`);
       return;
     }
 
-    this.setSpinnerText("Removing private key from OS keychain...");
+    this.setSpinnerText(`Removing private key for '${accountName}' from OS keychain...`);
 
     try {
-      await this.keychainManager.removePrivateKey();
-      this.succeedSpinner("Account locked! Private key removed from OS keychain.");
+      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

@@ -4,13 +4,13 @@ import {createClient, createAccount} from "genlayer-js";
 import type {GenLayerChain, Address, Hash} from "genlayer-js/types";
 import {readFileSync, existsSync} from "fs";
 import {ethers} from "ethers";
-import {KeystoreData} from "../../lib/interfaces/KeystoreData";
 
 export interface SendOptions {
   to: string;
   amount: string;
   rpc?: string;
   network?: string;
+  account?: string;
 }
 
 export class SendAction extends BaseAction {
@@ -48,14 +48,20 @@ export class SendAction extends BaseAction {
     this.startSpinner("Preparing transfer...");
 
     try {
-      const keypairPath = this.getConfigByKey("keyPairPath");
+      if (options.account) {
+        this.accountOverride = options.account;
+      }
+
+      const accountName = this.resolveAccountName();
+      const keystorePath = this.getKeystorePath(accountName);
 
-      if (!keypairPath || !existsSync(keypairPath)) {
-        this.failSpinner("No account found. Run 'genlayer account create' first.");
+      if (!existsSync(keystorePath)) {
+        this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
         return;
       }
 
-      const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+      const keystoreJson = readFileSync(keystorePath, "utf-8");
+      const keystoreData = JSON.parse(keystoreJson);
 
       if (!this.isValidKeystoreFormat(keystoreData)) {
         this.failSpinner("Invalid keystore format.");
@@ -63,16 +69,16 @@ export class SendAction extends BaseAction {
       }
 
       // Get private key
-      const cachedKey = await this.keychainManager.getPrivateKey();
+      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:");
+        const password = await this.promptPassword(`Enter password to unlock account '${accountName}':`);
         this.startSpinner("Preparing transfer...");
-        const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+        const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
         privateKey = wallet.privateKey;
       }
 

package/src/commands/account/show.ts

@@ -3,7 +3,11 @@ import {formatEther} from "viem";
 import {createClient} from "genlayer-js";
 import type {GenLayerChain, Address} from "genlayer-js/types";
 import {readFileSync, existsSync} from "fs";
-import {KeystoreData} from "../../lib/interfaces/KeystoreData";
+
+export interface ShowAccountOptions {
+  rpc?: string;
+  account?: string;
+}
 
 export class ShowAccountAction extends BaseAction {
   constructor() {
@@ -14,42 +18,52 @@ export class ShowAccountAction extends BaseAction {
     return resolveNetwork(this.getConfig().network);
   }
 
-  async execute(): Promise<void> {
+  async execute(options?: ShowAccountOptions): Promise<void> {
     this.startSpinner("Fetching account info...");
 
     try {
-      const keypairPath = this.getConfigByKey("keyPairPath");
+      if (options?.account) {
+        this.accountOverride = options.account;
+      }
+
+      const accountName = this.resolveAccountName();
+      const keystorePath = this.getKeystorePath(accountName);
 
-      if (!keypairPath || !existsSync(keypairPath)) {
-        this.failSpinner("No account found. Run 'genlayer account create' first.");
+      if (!existsSync(keystorePath)) {
+        this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
         return;
       }
 
-      const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+      const keystoreData = JSON.parse(readFileSync(keystorePath, "utf-8"));
 
       if (!this.isValidKeystoreFormat(keystoreData)) {
         this.failSpinner("Invalid keystore format.");
         return;
       }
 
-      const address = keystoreData.address as Address;
+      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.getPrivateKey();
+      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);

package/src/commands/account/unlock.ts

@@ -2,8 +2,12 @@ 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(): Promise<void> {
+  async execute(options?: UnlockAccountOptions): Promise<void> {
     this.startSpinner("Checking keychain availability...");
 
     const keychainAvailable = await this.keychainManager.isKeychainAvailable();
@@ -12,15 +16,21 @@ export class UnlockAccountAction extends BaseAction {
       return;
     }
 
-    this.setSpinnerText("Checking for existing account...");
+    if (options?.account) {
+      this.accountOverride = options.account;
+    }
+
+    const accountName = this.resolveAccountName();
+    this.setSpinnerText(`Checking for account '${accountName}'...`);
 
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync(keypairPath)) {
-      this.failSpinner("No account found. Run 'genlayer account create' first.");
+    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(keypairPath, "utf-8"));
+    const keystoreJson = readFileSync(keystorePath, "utf-8");
+    const keystoreData = JSON.parse(keystoreJson);
     if (!this.isValidKeystoreFormat(keystoreData)) {
       this.failSpinner("Invalid keystore format.");
       return;
@@ -29,11 +39,11 @@ export class UnlockAccountAction extends BaseAction {
     this.stopSpinner();
 
     try {
-      const password = await this.promptPassword("Enter password to unlock account:");
-      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+      const password = await this.promptPassword(`Enter password to unlock '${accountName}':`);
+      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
 
-      await this.keychainManager.storePrivateKey(wallet.privateKey);
-      this.succeedSpinner("Account unlocked! Private key cached in OS keychain.");
+      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);
+    }
+  }
+}

package/src/commands/network/index.ts

@@ -4,11 +4,26 @@ import {NetworkActions} from "./setNetwork";
 export function initializeNetworkCommands(program: Command) {
   const networkActions = new NetworkActions();
 
-  program
-    .command("network")
+  const network = program.command("network").description("Network configuration");
+
+  // genlayer network set [name]
+  network
+    .command("set")
     .description("Set the network to use")
-    .argument("[network]", "The network to use")
+    .argument("[network]", "The network to set")
     .action((networkName?: string) => networkActions.setNetwork(networkName));
 
+  // genlayer network info
+  network
+    .command("info")
+    .description("Show current network configuration and contract addresses")
+    .action(() => networkActions.showInfo());
+
+  // genlayer network list
+  network
+    .command("list")
+    .description("List available networks")
+    .action(() => networkActions.listNetworks());
+
   return program;
 }

package/src/commands/network/setNetwork.ts

@@ -1,32 +1,48 @@
-import {AiProviders} from "@/lib/config/simulator";
-import {BaseAction} from "../../lib/actions/BaseAction";
+import {BaseAction, BUILT_IN_NETWORKS, resolveNetwork} from "../../lib/actions/BaseAction";
 import inquirer, {DistinctQuestion} from "inquirer";
-import {localnet, studionet, testnetAsimov} from "genlayer-js/chains";
-import {} from "genlayer-js/chains";
-
-const networks = [
-  {
-    name: localnet.name,
-    alias: "localnet",
-    value: localnet,
-  },
-  {
-    name: studionet.name,
-    alias: "studionet",
-    value: studionet,
-  },
-  {
-    name: testnetAsimov.name,
-    alias: "testnet-asimov",
-    value: testnetAsimov,
-  },
-];
+
+const networks = Object.entries(BUILT_IN_NETWORKS).map(([alias, network]) => ({
+  name: network.name,
+  alias,
+  value: network,
+}));
 
 export class NetworkActions extends BaseAction {
   constructor() {
     super();
   }
 
+  async showInfo(): Promise<void> {
+    const storedNetwork = this.getConfigByKey("network") || "localnet";
+    const network = resolveNetwork(storedNetwork);
+
+    const info: Record<string, string> = {
+      alias: storedNetwork,
+      name: network.name,
+      chainId: network.id?.toString() || "unknown",
+      rpc: network.rpcUrls?.default?.http?.[0] || "unknown",
+      mainContract: network.consensusMainContract?.address || "not set",
+      stakingContract: network.stakingContract?.address || "not set",
+    };
+
+    if (network.blockExplorers?.default?.url) {
+      info.explorer = network.blockExplorers.default.url;
+    }
+
+    this.succeedSpinner("Current network", info);
+  }
+
+  async listNetworks(): Promise<void> {
+    const currentNetwork = this.getConfigByKey("network") || "localnet";
+
+    console.log("");
+    for (const net of networks) {
+      const marker = net.alias === currentNetwork ? "*" : " ";
+      console.log(`${marker} ${net.alias.padEnd(16)} ${net.name}`);
+    }
+    console.log("");
+  }
+
   async setNetwork(networkName?: string): Promise<void> {
     if (networkName || networkName === "") {
       if (!networks.some(n => n.name === networkName || n.alias === networkName)) {

package/src/commands/staking/StakingAction.ts

@@ -3,12 +3,15 @@ import {createClient, createAccount, formatStakingAmount, parseStakingAmount, ab
 import type {GenLayerClient, GenLayerChain, Address} from "genlayer-js/types";
 import {readFileSync, existsSync} from "fs";
 import {ethers} from "ethers";
-import {KeystoreData} from "../../lib/interfaces/KeystoreData";
+
+// Re-export for use by other staking commands
+export {BUILT_IN_NETWORKS};
 
 export interface StakingConfig {
   rpc?: string;
   stakingAddress?: string;
   network?: string;
+  account?: string;
 }
 
 export class StakingAction extends BaseAction {
@@ -33,6 +36,11 @@ export class StakingAction extends BaseAction {
 
   protected async getStakingClient(config: StakingConfig): Promise<GenLayerClient<GenLayerChain>> {
     if (!this._stakingClient) {
+      // Set account override if provided
+      if (config.account) {
+        this.accountOverride = config.account;
+      }
+
       const network = this.getNetwork(config);
 
       // Override staking address if provided
@@ -56,6 +64,11 @@ export class StakingAction extends BaseAction {
   }
 
   protected async getReadOnlyStakingClient(config: StakingConfig): Promise<GenLayerClient<GenLayerChain>> {
+    // Set account override if provided
+    if (config.account) {
+      this.accountOverride = config.account;
+    }
+
     const network = this.getNetwork(config);
 
     if (config.stakingAddress) {
@@ -65,44 +78,61 @@ export class StakingAction extends BaseAction {
       };
     }
 
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync(keypairPath)) {
-      throw new Error("No account found. Run 'genlayer account create' first.");
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
+
+    if (!existsSync(keystorePath)) {
+      throw new Error(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
     }
 
-    const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+    const keystoreData = JSON.parse(readFileSync(keystorePath, "utf-8"));
+    const addr = keystoreData.address as string;
+    const normalizedAddress = (addr.startsWith("0x") ? addr : `0x${addr}`) as Address;
 
     return createClient({
       chain: network,
       endpoint: config.rpc,
-      account: keystoreData.address as Address,
+      account: normalizedAddress,
     });
   }
 
   private async getPrivateKeyForStaking(): Promise<string> {
-    const keypairPath = this.getConfigByKey("keyPairPath");
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
 
-    if (!keypairPath || !existsSync(keypairPath)) {
-      throw new Error("No account found. Run 'genlayer account create' first.");
+    if (!existsSync(keystorePath)) {
+      throw new Error(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
     }
 
-    const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+    const keystoreJson = readFileSync(keystorePath, "utf-8");
+    const keystoreData = JSON.parse(keystoreJson);
 
     if (!this.isValidKeystoreFormat(keystoreData)) {
       throw new Error("Invalid keystore format.");
     }
 
-    const cachedKey = await this.keychainManager.getPrivateKey();
+    const cachedKey = await this.keychainManager.getPrivateKey(accountName);
     if (cachedKey) {
-      return cachedKey;
+      // Verify cached key matches keystore address - safety check
+      const tempAccount = createAccount(cachedKey as `0x${string}`);
+      const cachedAddress = tempAccount.address.toLowerCase();
+      const keystoreAddress = `0x${keystoreData.address.toLowerCase().replace(/^0x/, '')}`;
+
+      if (cachedAddress !== keystoreAddress) {
+        // Cached key doesn't match keystore - invalidate it
+        await this.keychainManager.removePrivateKey(accountName);
+        // Fall through to prompt for password
+      } else {
+        return cachedKey;
+      }
     }
 
     // Stop spinner before prompting for password
     this.stopSpinner();
-    const password = await this.promptPassword("Enter password to unlock account:");
+    const password = await this.promptPassword(`Enter password to unlock account '${accountName}':`);
     this.startSpinner("Continuing...");
 
-    const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+    const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
     return wallet.privateKey;
   }
 
@@ -115,11 +145,13 @@ export class StakingAction extends BaseAction {
   }
 
   protected async getSignerAddress(): Promise<Address> {
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync(keypairPath)) {
-      throw new Error("Keypair file not found.");
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
+    if (!existsSync(keystorePath)) {
+      throw new Error(`Account '${accountName}' not found.`);
     }
-    const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
-    return keystoreData.address as Address;
+    const keystoreData = JSON.parse(readFileSync(keystorePath, "utf-8"));
+    const addr = keystoreData.address as string;
+    return (addr.startsWith("0x") ? addr : `0x${addr}`) as Address;
   }
 }

package/src/commands/staking/delegatorJoin.ts

@@ -1,5 +1,6 @@
 import {StakingAction, StakingConfig} from "./StakingAction";
 import type {Address} from "genlayer-js/types";
+import chalk from "chalk";
 
 export interface DelegatorJoinOptions extends StakingConfig {
   validator: string;
@@ -35,6 +36,7 @@ export class DelegatorJoinAction extends StakingAction {
       };
 
       this.succeedSpinner("Successfully joined as delegator!", output);
+      console.log(chalk.dim(`\nTo view your delegation: genlayer staking delegation-info --validator ${options.validator}`));
     } catch (error: any) {
       this.failSpinner("Failed to join as delegator", error.message || error);
     }