genlayer 0.32.1 → 0.32.2

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+## 0.32.2 (2025-12-04)
+
 ## 0.32.1 (2025-12-04)
 
 ## 0.32.0 (2025-12-03)

package/dist/index.js

@@ -18249,7 +18249,7 @@ var require_semver2 = __commonJS({
 import { program } from "commander";
 
 // package.json
-var version = "0.32.1";
+var version = "0.32.2";
 var package_default = {
   name: "genlayer",
   version,
@@ -19922,7 +19922,19 @@ var ConfigFileManager = class {
 };
 
 // src/lib/config/KeychainManager.ts
-import { default as keytar } from "keytar";
+var keytarModule = null;
+var keytarLoadAttempted = false;
+async function getKeytar() {
+  if (keytarLoadAttempted) return keytarModule;
+  keytarLoadAttempted = true;
+  try {
+    const mod3 = await import("keytar");
+    keytarModule = mod3.default ?? mod3;
+    return keytarModule;
+  } catch {
+    return null;
+  }
+}
 var _KeychainManager = class _KeychainManager {
   constructor() {
   }
@@ -19931,6 +19943,8 @@ var _KeychainManager = class _KeychainManager {
   }
   async isKeychainAvailable() {
     try {
+      const keytar = await getKeytar();
+      if (!keytar) return false;
       await keytar.findCredentials("test-service");
       return true;
     } catch {
@@ -19938,17 +19952,44 @@ var _KeychainManager = class _KeychainManager {
     }
   }
   async storePrivateKey(accountName, privateKey) {
-    return await keytar.setPassword(_KeychainManager.SERVICE, this.getKeychainAccount(accountName), privateKey);
+    const keytar = await getKeytar();
+    if (!keytar) throw new Error("Keychain not available. Install libsecret-1-dev on Linux.");
+    try {
+      return await keytar.setPassword(_KeychainManager.SERVICE, this.getKeychainAccount(accountName), privateKey);
+    } catch (error) {
+      if (error?.message?.includes("org.freedesktop.secrets")) {
+        throw new Error("Keychain service not running. Install and start gnome-keyring or another secrets service.");
+      }
+      throw error;
+    }
   }
   async getPrivateKey(accountName) {
-    return await keytar.getPassword(_KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    const keytar = await getKeytar();
+    if (!keytar) return null;
+    try {
+      return await keytar.getPassword(_KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    } catch {
+      return null;
+    }
   }
   async removePrivateKey(accountName) {
-    return await keytar.deletePassword(_KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    const keytar = await getKeytar();
+    if (!keytar) return false;
+    try {
+      return await keytar.deletePassword(_KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    } catch {
+      return false;
+    }
   }
   async listUnlockedAccounts() {
-    const credentials = await keytar.findCredentials(_KeychainManager.SERVICE);
-    return credentials.map((c) => c.account).filter((a) => a.startsWith("account:")).map((a) => a.replace("account:", ""));
+    const keytar = await getKeytar();
+    if (!keytar) return [];
+    try {
+      const credentials = await keytar.findCredentials(_KeychainManager.SERVICE);
+      return credentials.map((c) => c.account).filter((a) => a.startsWith("account:")).map((a) => a.replace("account:", ""));
+    } catch {
+      return [];
+    }
   }
   async isAccountUnlocked(accountName) {
     const key = await this.getPrivateKey(accountName);
@@ -49906,15 +49947,19 @@ Network set to: ${BUILT_IN_NETWORKS[selectedNetwork].name}
     const minStakeRaw = epochInfo.validatorMinStakeRaw;
     const minStakeFormatted = epochInfo.validatorMinStake;
     const currentEpoch = epochInfo.currentEpoch;
+    const MIN_GAS_BUFFER = parseEther("0.01");
     console.log(`Balance: ${balanceFormatted} GEN`);
     console.log(`Minimum stake required: ${minStakeFormatted}`);
     if (currentEpoch === 0n) {
-      console.log("(Epoch 0: minimum stake not enforced)");
+      console.log("(Epoch 0: minimum stake not enforced, but gas fees still required)");
+      console.log(`Note: Validator won't become active until self-stake reaches ${minStakeFormatted}`);
     }
-    if (currentEpoch !== 0n && balance < minStakeRaw) {
+    const minRequired = currentEpoch === 0n ? MIN_GAS_BUFFER : minStakeRaw + MIN_GAS_BUFFER;
+    if (balance < minRequired) {
       console.log("");
+      const minFormatted = currentEpoch === 0n ? "0.01 GEN (for gas)" : `${minStakeFormatted} + gas`;
       this.failSpinner(
-        `Insufficient balance. You need at least ${minStakeFormatted} to become a validator.
+        `Insufficient balance. You need at least ${minFormatted} to become a validator.
 Fund your account (${state.accountAddress}) and run the wizard again.`
       );
     }

package/docs/validator-guide.md

@@ -2,6 +2,8 @@
 
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.32.1",
+  "version": "0.32.2",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "type": "module",

package/src/commands/staking/wizard.ts

@@ -3,7 +3,7 @@ import {CreateAccountAction} from "../account/create";
 import {ExportAccountAction} from "../account/export";
 import inquirer from "inquirer";
 import type {Address} from "genlayer-js/types";
-import {formatEther} from "viem";
+import {formatEther, parseEther} from "viem";
 import {createClient} from "genlayer-js";
 import {readFileSync, existsSync} from "fs";
 import path from "path";
@@ -247,17 +247,24 @@ export class ValidatorWizardAction extends StakingAction {
     const minStakeFormatted = epochInfo.validatorMinStake;
     const currentEpoch = epochInfo.currentEpoch;
 
+    // Minimum gas buffer for transaction fees (~0.01 GEN)
+    const MIN_GAS_BUFFER = parseEther("0.01");
+
     console.log(`Balance: ${balanceFormatted} GEN`);
     console.log(`Minimum stake required: ${minStakeFormatted}`);
     if (currentEpoch === 0n) {
-      console.log("(Epoch 0: minimum stake not enforced)");
+      console.log("(Epoch 0: minimum stake not enforced, but gas fees still required)");
+      console.log(`Note: Validator won't become active until self-stake reaches ${minStakeFormatted}`);
     }
 
-    // Epoch 0 doesn't enforce min stake, so only check for non-zero epochs
-    if (currentEpoch !== 0n && balance < minStakeRaw) {
+    // Always need gas, plus stake requirement after Epoch 0
+    const minRequired = currentEpoch === 0n ? MIN_GAS_BUFFER : minStakeRaw + MIN_GAS_BUFFER;
+
+    if (balance < minRequired) {
       console.log("");
+      const minFormatted = currentEpoch === 0n ? "0.01 GEN (for gas)" : `${minStakeFormatted} + gas`;
       this.failSpinner(
-        `Insufficient balance. You need at least ${minStakeFormatted} to become a validator.\n` +
+        `Insufficient balance. You need at least ${minFormatted} to become a validator.\n` +
           `Fund your account (${state.accountAddress}) and run the wizard again.`
       );
     }

package/src/lib/config/KeychainManager.ts

@@ -1,4 +1,19 @@
-import {default as keytar} from 'keytar';
+type Keytar = typeof import('keytar').default;
+
+let keytarModule: Keytar | null = null;
+let keytarLoadAttempted = false;
+
+async function getKeytar(): Promise<Keytar | null> {
+  if (keytarLoadAttempted) return keytarModule;
+  keytarLoadAttempted = true;
+  try {
+    const mod = await import('keytar');
+    keytarModule = mod.default ?? mod;
+    return keytarModule;
+  } catch {
+    return null;
+  }
+}
 
 export class KeychainManager {
   private static readonly SERVICE = 'genlayer-cli';
@@ -11,6 +26,8 @@ export class KeychainManager {
 
   async isKeychainAvailable(): Promise<boolean> {
     try {
+      const keytar = await getKeytar();
+      if (!keytar) return false;
       await keytar.findCredentials('test-service');
       return true;
     } catch {
@@ -19,23 +36,50 @@ export class KeychainManager {
   }
 
   async storePrivateKey(accountName: string, privateKey: string): Promise<void> {
-    return await keytar.setPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName), privateKey);
+    const keytar = await getKeytar();
+    if (!keytar) throw new Error('Keychain not available. Install libsecret-1-dev on Linux.');
+    try {
+      return await keytar.setPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName), privateKey);
+    } catch (error: any) {
+      if (error?.message?.includes('org.freedesktop.secrets')) {
+        throw new Error('Keychain service not running. Install and start gnome-keyring or another secrets service.');
+      }
+      throw error;
+    }
   }
 
   async getPrivateKey(accountName: string): Promise<string | null> {
-    return await keytar.getPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    const keytar = await getKeytar();
+    if (!keytar) return null;
+    try {
+      return await keytar.getPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    } catch {
+      return null;
+    }
   }
 
   async removePrivateKey(accountName: string): Promise<boolean> {
-    return await keytar.deletePassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    const keytar = await getKeytar();
+    if (!keytar) return false;
+    try {
+      return await keytar.deletePassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    } catch {
+      return false;
+    }
   }
 
   async listUnlockedAccounts(): Promise<string[]> {
-    const credentials = await keytar.findCredentials(KeychainManager.SERVICE);
-    return credentials
-      .map(c => c.account)
-      .filter(a => a.startsWith('account:'))
-      .map(a => a.replace('account:', ''));
+    const keytar = await getKeytar();
+    if (!keytar) return [];
+    try {
+      const credentials = await keytar.findCredentials(KeychainManager.SERVICE);
+      return credentials
+        .map(c => c.account)
+        .filter(a => a.startsWith('account:'))
+        .map(a => a.replace('account:', ''));
+    } catch {
+      return [];
+    }
   }
 
   async isAccountUnlocked(accountName: string): Promise<boolean> {

package/tests/libs/keychainManager.test.ts

@@ -75,10 +75,12 @@ describe("KeychainManager", () => {
       expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
 
-    test("handles retrieval error", async () => {
+    test("returns null on retrieval error", async () => {
       vi.mocked(keytar.getPassword).mockRejectedValue(new Error("Retrieval failed"));
 
-      await expect(keychainManager.getPrivateKey("main")).rejects.toThrow("Retrieval failed");
+      const result = await keychainManager.getPrivateKey("main");
+
+      expect(result).toBeNull();
       expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
   });
@@ -102,10 +104,12 @@ describe("KeychainManager", () => {
       expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
 
-    test("handles removal error", async () => {
+    test("returns false on removal error", async () => {
       vi.mocked(keytar.deletePassword).mockRejectedValue(new Error("Removal failed"));
 
-      await expect(keychainManager.removePrivateKey("main")).rejects.toThrow("Removal failed");
+      const result = await keychainManager.removePrivateKey("main");
+
+      expect(result).toBe(false);
       expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
     });
   });