genlayer 0.32.0 → 0.32.2

package/dist/index.js

@@ -18249,7 +18249,7 @@ var require_semver2 = __commonJS({
 import { program } from "commander";
 
 // package.json
-var version = "0.32.0";
+var version = "0.32.2";
 var package_default = {
   name: "genlayer",
   version,
@@ -18317,7 +18317,7 @@ var package_default = {
     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",
@@ -19771,21 +19771,79 @@ var ConfigFileManager = class {
   constructor(baseFolder = ".genlayer/", configFileName = "genlayer-config.json") {
     __publicField(this, "folderPath");
     __publicField(this, "configFilePath");
+    __publicField(this, "keystoresPath");
     this.folderPath = path.resolve(os.homedir(), baseFolder);
     this.configFilePath = path.resolve(this.folderPath, configFileName);
+    this.keystoresPath = path.resolve(this.folderPath, "keystores");
     this.ensureFolderExists();
+    this.ensureKeystoresDirExists();
     this.ensureConfigFileExists();
+    this.migrateOldConfig();
+    this.migrateKeystoreFormats();
   }
   ensureFolderExists() {
     if (!fs2.existsSync(this.folderPath)) {
       fs2.mkdirSync(this.folderPath, { recursive: true });
     }
   }
+  ensureKeystoresDirExists() {
+    if (!fs2.existsSync(this.keystoresPath)) {
+      fs2.mkdirSync(this.keystoresPath, { recursive: true });
+    }
+  }
   ensureConfigFileExists() {
     if (!fs2.existsSync(this.configFilePath)) {
       fs2.writeFileSync(this.configFilePath, JSON.stringify({}, null, 2));
     }
   }
+  migrateOldConfig() {
+    const config = this.getConfig();
+    if (config.keyPairPath && !config.activeAccount) {
+      const oldPath = config.keyPairPath;
+      if (fs2.existsSync(oldPath)) {
+        const newPath = this.getKeystorePath("default");
+        const content = fs2.readFileSync(oldPath, "utf-8");
+        const web3Content = this.convertToWeb3Format(content);
+        fs2.writeFileSync(newPath, web3Content);
+        delete config.keyPairPath;
+        config.activeAccount = "default";
+        fs2.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
+      }
+    }
+  }
+  migrateKeystoreFormats() {
+    if (!fs2.existsSync(this.keystoresPath)) {
+      return;
+    }
+    const files = fs2.readdirSync(this.keystoresPath);
+    if (!Array.isArray(files)) {
+      return;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const filePath = path.resolve(this.keystoresPath, file);
+      try {
+        const content = fs2.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (parsed.encrypted && typeof parsed.encrypted === "string") {
+          const web3Content = this.convertToWeb3Format(content);
+          fs2.writeFileSync(filePath, web3Content);
+        }
+      } catch {
+      }
+    }
+  }
+  convertToWeb3Format(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed.encrypted && typeof parsed.encrypted === "string") {
+        return parsed.encrypted;
+      }
+      return content;
+    } catch {
+      return content;
+    }
+  }
   getFolderPath() {
     return this.folderPath;
   }
@@ -19805,33 +19863,140 @@ var ConfigFileManager = class {
     config[key] = value;
     fs2.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
   }
+  removeConfig(key) {
+    const config = this.getConfig();
+    delete config[key];
+    fs2.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
+  }
+  getKeystoresPath() {
+    return this.keystoresPath;
+  }
+  getKeystorePath(name) {
+    return path.resolve(this.keystoresPath, `${name}.json`);
+  }
+  accountExists(name) {
+    return fs2.existsSync(this.getKeystorePath(name));
+  }
+  getActiveAccount() {
+    return this.getConfigByKey("activeAccount");
+  }
+  setActiveAccount(name) {
+    if (!this.accountExists(name)) {
+      throw new Error(`Account '${name}' does not exist`);
+    }
+    this.writeConfig("activeAccount", name);
+  }
+  listAccounts() {
+    if (!fs2.existsSync(this.keystoresPath)) {
+      return [];
+    }
+    const files = fs2.readdirSync(this.keystoresPath);
+    const accounts = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const name = file.replace(".json", "");
+      const filePath = this.getKeystorePath(name);
+      try {
+        const content = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+        const addr = content.address || "unknown";
+        accounts.push({
+          name,
+          address: addr.startsWith("0x") ? addr : `0x${addr}`,
+          path: filePath
+        });
+      } catch {
+      }
+    }
+    return accounts;
+  }
+  removeAccount(name) {
+    const keystorePath = this.getKeystorePath(name);
+    if (!fs2.existsSync(keystorePath)) {
+      throw new Error(`Account '${name}' does not exist`);
+    }
+    fs2.unlinkSync(keystorePath);
+    if (this.getActiveAccount() === name) {
+      this.removeConfig("activeAccount");
+    }
+  }
 };
 
 // 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() {
   }
+  getKeychainAccount(accountName) {
+    return `account:${accountName}`;
+  }
   async isKeychainAvailable() {
     try {
+      const keytar = await getKeytar();
+      if (!keytar) return false;
       await keytar.findCredentials("test-service");
       return true;
     } catch {
       return false;
     }
   }
-  async storePrivateKey(privateKey) {
-    return await keytar.setPassword(_KeychainManager.SERVICE, _KeychainManager.ACCOUNT, privateKey);
+  async storePrivateKey(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() {
-    return await keytar.getPassword(_KeychainManager.SERVICE, _KeychainManager.ACCOUNT);
+  async getPrivateKey(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) {
+    const keytar = await getKeytar();
+    if (!keytar) return false;
+    try {
+      return await keytar.deletePassword(_KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    } catch {
+      return false;
+    }
   }
-  async removePrivateKey() {
-    return await keytar.deletePassword(_KeychainManager.SERVICE, _KeychainManager.ACCOUNT);
+  async listUnlockedAccounts() {
+    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);
+    return key !== null;
   }
 };
 __publicField(_KeychainManager, "SERVICE", "genlayer-cli");
-__publicField(_KeychainManager, "ACCOUNT", "default-user");
 var KeychainManager = _KeychainManager;
 
 // node_modules/ora/index.js
@@ -31516,12 +31681,13 @@ function custom(provider, config = {}) {
 // node_modules/viem/_esm/index.js
 init_base();
 init_contract();
+init_decodeErrorResult();
 init_encodeFunctionData();
 init_fromHex();
 init_toHex();
 init_formatEther();
 
-// node_modules/genlayer-js/dist/chunk-NZI52PRP.js
+// node_modules/genlayer-js/dist/chunk-RW6PLN5W.js
 var chains_exports = {};
 __export2(chains_exports, {
   localnet: () => localnet,
@@ -39550,6 +39716,13 @@ var studionet = defineChain({
   defaultConsensusMaxRotations: 3
 });
 var VALIDATOR_WALLET_ABI = [
+  // Custom errors
+  { name: "NotOperator", type: "error", inputs: [] },
+  { name: "InvalidAddress", type: "error", inputs: [] },
+  { name: "TransferFailed", type: "error", inputs: [] },
+  { name: "OperatorTransferNotReady", type: "error", inputs: [] },
+  { name: "NoPendingOperator", type: "error", inputs: [] },
+  // Functions
   {
     name: "operator",
     type: "function",
@@ -39613,19 +39786,51 @@ var VALIDATOR_WALLET_ABI = [
   }
 ];
 var STAKING_ABI = [
-  // Custom errors
-  { name: "BelowMinStake", type: "error", inputs: [] },
-  { name: "AlreadyValidator", type: "error", inputs: [] },
-  { name: "NotValidator", type: "error", inputs: [] },
-  { name: "NotOwner", type: "error", inputs: [] },
-  { name: "NotOperator", type: "error", inputs: [] },
-  { name: "ValidatorBanned", type: "error", inputs: [] },
-  { name: "ValidatorQuarantined", type: "error", inputs: [] },
-  { name: "InsufficientShares", type: "error", inputs: [] },
-  { name: "NothingToClaim", type: "error", inputs: [] },
-  { name: "NotYetClaimable", type: "error", inputs: [] },
-  { name: "ZeroAmount", type: "error", inputs: [] },
-  { name: "InvalidOperator", type: "error", inputs: [] },
+  // Custom errors from IGenLayerStaking
+  { name: "OnlyGEN", type: "error", inputs: [] },
+  { name: "OnlyTribunal", type: "error", inputs: [] },
+  { name: "OnlyIdleness", type: "error", inputs: [] },
+  { name: "OnlyTransactions", type: "error", inputs: [] },
+  { name: "OnlyIdlenessOrTribunal", type: "error", inputs: [] },
+  { name: "OnlyTransactionsOrTribunal", type: "error", inputs: [] },
+  { name: "InvalidAtEpoch", type: "error", inputs: [] },
+  { name: "MaxValidatorsCannotBeZero", type: "error", inputs: [] },
+  { name: "ValidatorExitExceedsShares", type: "error", inputs: [] },
+  { name: "DelegatorExitExceedsShares", type: "error", inputs: [] },
+  { name: "DelegatorMayNotJoinWithZeroValue", type: "error", inputs: [] },
+  { name: "DelegatorMayNotJoinTwoValidatorsSimultaneously", type: "error", inputs: [] },
+  { name: "DelegatorBelowMinimumStake", type: "error", inputs: [] },
+  { name: "DelegatorExitWouldBeBelowMinimum", type: "error", inputs: [] },
+  { name: "ValidatorNotActive", type: "error", inputs: [] },
+  { name: "ValidatorMayNotBeDelegator", type: "error", inputs: [] },
+  { name: "ValidatorMustNotBeDelegator", type: "error", inputs: [] },
+  { name: "ValidatorMayNotJoinWithZeroValue", type: "error", inputs: [] },
+  { name: "ValidatorMayNotDepositZeroValue", type: "error", inputs: [] },
+  { name: "ValidatorWithdrawalExceedsStake", type: "error", inputs: [] },
+  { name: "ValidatorAlreadyJoined", type: "error", inputs: [] },
+  { name: "ValidatorNotJoined", type: "error", inputs: [] },
+  { name: "ValidatorBelowMinimumStake", type: "error", inputs: [] },
+  { name: "OperatorAlreadyAssigned", type: "error", inputs: [] },
+  { name: "InvalidOperatorAddress", type: "error", inputs: [] },
+  { name: "MaxNumberOfValidatorsReached", type: "error", inputs: [] },
+  { name: "ValidatorsConsumed", type: "error", inputs: [] },
+  { name: "ValidatorsUnavailable", type: "error", inputs: [] },
+  { name: "EpochNotFinished", type: "error", inputs: [] },
+  { name: "EpochNotFinalized", type: "error", inputs: [] },
+  { name: "InflationInvalidAmount", type: "error", inputs: [] },
+  { name: "InflationAlreadyReceived", type: "error", inputs: [] },
+  { name: "InflationAlreadyInitialized", type: "error", inputs: [] },
+  { name: "EpochAlreadyFinalized", type: "error", inputs: [] },
+  { name: "PendingTribunals", type: "error", inputs: [{ name: "epoch", type: "uint256" }] },
+  { name: "FailedTransfer", type: "error", inputs: [{ name: "validator", type: "address" }] },
+  { name: "NFTMinterCallFailed", type: "error", inputs: [] },
+  { name: "DeepthoughtCallFailed", type: "error", inputs: [] },
+  { name: "NFTMinterNotConfigured", type: "error", inputs: [] },
+  { name: "NumberOfValidatorsExceedsAvailable", type: "error", inputs: [] },
+  { name: "EpochAdvanceNotReady", type: "error", inputs: [] },
+  { name: "PreviousEpochNotFinalizable", type: "error", inputs: [] },
+  { name: "NoBurning", type: "error", inputs: [] },
+  { name: "ReductionFactorCannotBeZero", type: "error", inputs: [] },
   // Validator functions
   {
     name: "validatorJoin",
@@ -39841,6 +40046,13 @@ var STAKING_ABI = [
     inputs: [],
     outputs: [{ name: "", type: "uint256" }]
   },
+  {
+    name: "epochZeroMinDuration",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
   {
     name: "getQuarantinedValidators",
     type: "function",
@@ -45214,19 +45426,19 @@ var decodeTransaction = (tx) => {
   return decodedTx;
 };
 var simplifyTransactionReceipt = (tx) => {
-  const simplifyObject = (obj, path6 = "") => {
+  const simplifyObject = (obj, path8 = "") => {
     if (obj === null || obj === void 0) return obj;
     if (Array.isArray(obj)) {
-      return obj.map((item) => simplifyObject(item, path6)).filter((item) => item !== void 0);
+      return obj.map((item) => simplifyObject(item, path8)).filter((item) => item !== void 0);
     }
     if (typeof obj === "object") {
       const result = {};
       for (const [key, value] of Object.entries(obj)) {
-        const currentPath = path6 ? `${path6}.${key}` : key;
+        const currentPath = path8 ? `${path8}.${key}` : key;
         if (FIELDS_TO_REMOVE.includes(key)) {
           continue;
         }
-        if (key === "node_config" && !path6.includes("consensus_data")) {
+        if (key === "node_config" && !path8.includes("consensus_data")) {
           continue;
         }
         if (key === "consensus_data" && typeof value === "object" && value !== null) {
@@ -45514,11 +45726,45 @@ function formatStakingAmount(amount) {
 }
 var FALLBACK_GAS = 1000000n;
 var GAS_BUFFER_MULTIPLIER = 2n;
+var COMBINED_ERROR_ABI = [...STAKING_ABI, ...VALIDATOR_WALLET_ABI];
 function extractRevertReason(err) {
   if (err instanceof BaseError2) {
+    const rawError = err.walk((e2) => e2 instanceof RawContractError);
+    if (rawError instanceof RawContractError && rawError.data && typeof rawError.data === "string") {
+      try {
+        const decoded = decodeErrorResult({
+          abi: COMBINED_ERROR_ABI,
+          data: rawError.data
+        });
+        return decoded.errorName;
+      } catch {
+      }
+    }
+    let current = err;
+    while (current) {
+      if (current && typeof current === "object") {
+        const obj = current;
+        if (obj.data && typeof obj.data === "string" && obj.data.startsWith("0x")) {
+          try {
+            const decoded = decodeErrorResult({
+              abi: COMBINED_ERROR_ABI,
+              data: obj.data
+            });
+            return decoded.errorName;
+          } catch {
+          }
+        }
+        current = obj.cause;
+      } else {
+        break;
+      }
+    }
     const revertError = err.walk((e2) => e2 instanceof ContractFunctionRevertedError);
     if (revertError instanceof ContractFunctionRevertedError) {
-      return revertError.data?.errorName || revertError.reason || "Unknown reason";
+      if (revertError.data?.errorName) {
+        return revertError.data.errorName;
+      }
+      return revertError.reason || "Unknown reason";
     }
     if (err.shortMessage) return err.shortMessage;
   }
@@ -45913,12 +46159,22 @@ var stakingActions = (client, publicClient) => {
     },
     getEpochInfo: async () => {
       const contract = getReadOnlyStakingContract();
-      const [epoch, validatorMinStake, delegatorMinStake, activeCount, epochMinDuration, epochOdd, epochEven] = await Promise.all([
+      const [
+        epoch,
+        validatorMinStake,
+        delegatorMinStake,
+        activeCount,
+        epochMinDuration,
+        epochZeroMinDuration,
+        epochOdd,
+        epochEven
+      ] = await Promise.all([
         contract.read.epoch(),
         contract.read.validatorMinStake(),
         contract.read.delegatorMinStake(),
         contract.read.activeValidatorsCount(),
         contract.read.epochMinDuration(),
+        contract.read.epochZeroMinDuration(),
         contract.read.epochOdd(),
         contract.read.epochEven()
       ]);
@@ -45927,7 +46183,8 @@ var stakingActions = (client, publicClient) => {
       const currentEpochEnd = currentEpochData.end > 0n ? new Date(Number(currentEpochData.end) * 1e3) : null;
       let nextEpochEstimate = null;
       if (!currentEpochEnd) {
-        const estimatedEndMs = Number(currentEpochData.start + epochMinDuration) * 1e3;
+        const duration = epoch === 0n ? epochZeroMinDuration : epochMinDuration;
+        const estimatedEndMs = Number(currentEpochData.start + duration) * 1e3;
         nextEpochEstimate = new Date(estimatedEndMs);
       }
       return {
@@ -46136,25 +46393,26 @@ var _BaseAction = class _BaseAction extends ConfigFileManager {
     __publicField(this, "spinner");
     __publicField(this, "_genlayerClient", null);
     __publicField(this, "keychainManager");
+    __publicField(this, "accountOverride", null);
     this.spinner = ora({ text: "", spinner: "dots" });
     this.keychainManager = new KeychainManager();
   }
-  async decryptKeystore(keystoreData, attempt = 1) {
+  async decryptKeystore(keystoreJson, attempt = 1) {
     try {
       const message = attempt === 1 ? "Enter password to decrypt keystore:" : `Invalid password. Attempt ${attempt}/${_BaseAction.MAX_PASSWORD_ATTEMPTS} - Enter password to decrypt keystore:`;
       const password = await this.promptPassword(message);
-      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
       return wallet.privateKey;
     } catch (error) {
       if (attempt >= _BaseAction.MAX_PASSWORD_ATTEMPTS) {
         this.failSpinner(`Maximum password attempts exceeded (${_BaseAction.MAX_PASSWORD_ATTEMPTS}/${_BaseAction.MAX_PASSWORD_ATTEMPTS}).`);
       }
-      return await this.decryptKeystore(keystoreData, attempt + 1);
+      return await this.decryptKeystore(keystoreJson, attempt + 1);
     }
   }
   isValidKeystoreFormat(data) {
     return Boolean(
-      data && data.version === 1 && typeof data.encrypted === "string" && typeof data.address === "string"
+      data && (data.crypto || data.Crypto) && typeof data.address === "string"
     );
   }
   formatOutput(data) {
@@ -46175,40 +46433,64 @@ var _BaseAction = class _BaseAction extends ConfigFileManager {
     }
     return this._genlayerClient;
   }
+  resolveAccountName() {
+    if (this.accountOverride) {
+      return this.accountOverride;
+    }
+    const activeAccount = this.getActiveAccount();
+    if (activeAccount) {
+      return activeAccount;
+    }
+    return _BaseAction.DEFAULT_ACCOUNT_NAME;
+  }
   async getAccount(readOnly = false) {
-    let keypairPath = this.getConfigByKey("keyPairPath");
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
     let decryptedPrivateKey;
+    let keystoreJson;
     let keystoreData;
-    if (!keypairPath || !existsSync(keypairPath)) {
-      await this.confirmPrompt("Keypair file not found. Would you like to create a new keypair?");
-      decryptedPrivateKey = await this.createKeypair(_BaseAction.DEFAULT_KEYSTORE_PATH, false);
-      keypairPath = this.getConfigByKey("keyPairPath");
+    if (!existsSync(keystorePath)) {
+      await this.confirmPrompt(`Account '${accountName}' not found. Would you like to create it?`);
+      decryptedPrivateKey = await this.createKeypairByName(accountName, false);
     }
-    keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+    keystoreJson = readFileSync(keystorePath, "utf-8");
+    keystoreData = JSON.parse(keystoreJson);
     if (!this.isValidKeystoreFormat(keystoreData)) {
       this.failSpinner("Invalid keystore format. Expected encrypted keystore file.", void 0, false);
-      await this.confirmPrompt("Would you like to create a new keypair?");
-      decryptedPrivateKey = await this.createKeypair(_BaseAction.DEFAULT_KEYSTORE_PATH, true);
-      keypairPath = this.getConfigByKey("keyPairPath");
-      keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+      await this.confirmPrompt(`Would you like to recreate account '${accountName}'?`);
+      decryptedPrivateKey = await this.createKeypairByName(accountName, true);
+      keystoreJson = readFileSync(keystorePath, "utf-8");
+      keystoreData = JSON.parse(keystoreJson);
     }
     if (readOnly) {
       return this.getAddress(keystoreData);
     }
     if (!decryptedPrivateKey) {
-      const cachedKey = await this.keychainManager.getPrivateKey();
-      decryptedPrivateKey = cachedKey ? cachedKey : await this.decryptKeystore(keystoreData);
+      const cachedKey = await this.keychainManager.getPrivateKey(accountName);
+      if (cachedKey) {
+        const tempAccount = createAccount(cachedKey);
+        const cachedAddress = tempAccount.address.toLowerCase();
+        const keystoreAddress = `0x${keystoreData.address.toLowerCase().replace(/^0x/, "")}`;
+        if (cachedAddress === keystoreAddress) {
+          decryptedPrivateKey = cachedKey;
+        } else {
+          await this.keychainManager.removePrivateKey(accountName);
+          decryptedPrivateKey = await this.decryptKeystore(keystoreJson);
+        }
+      } else {
+        decryptedPrivateKey = await this.decryptKeystore(keystoreJson);
+      }
     }
     return createAccount(decryptedPrivateKey);
   }
   getAddress(keystoreData) {
     return keystoreData.address;
   }
-  async createKeypair(outputPath, overwrite) {
-    const finalOutputPath = this.getFilePath(outputPath);
+  async createKeypairByName(accountName, overwrite) {
+    const keystorePath = this.getKeystorePath(accountName);
     this.stopSpinner();
-    if (existsSync(finalOutputPath) && !overwrite) {
-      this.failSpinner(`The file at ${finalOutputPath} already exists. Use the '--overwrite' option to replace it.`);
+    if (existsSync(keystorePath) && !overwrite) {
+      this.failSpinner(`Account '${accountName}' already exists. Use '--overwrite' to replace it.`);
     }
     const wallet = ethers.Wallet.createRandom();
     const password = await this.promptPassword("Enter a password to encrypt your keystore (minimum 8 characters):");
@@ -46220,14 +46502,11 @@ var _BaseAction = class _BaseAction extends ConfigFileManager {
       this.failSpinner(`Password must be at least ${_BaseAction.MIN_PASSWORD_LENGTH} characters long`);
     }
     const encryptedJson = await wallet.encrypt(password);
-    const keystoreData = {
-      version: 1,
-      encrypted: encryptedJson,
-      address: wallet.address
-    };
-    writeFileSync(finalOutputPath, JSON.stringify(keystoreData, null, 2));
-    this.writeConfig("keyPairPath", finalOutputPath);
-    await this.keychainManager.removePrivateKey();
+    writeFileSync(keystorePath, encryptedJson);
+    if (!this.getActiveAccount()) {
+      this.setActiveAccount(accountName);
+    }
+    await this.keychainManager.removePrivateKey(accountName);
     return wallet.privateKey;
   }
   async promptPassword(message) {
@@ -46310,7 +46589,7 @@ ${message}`));
     this.spinner.text = source_default.blue(message);
   }
 };
-__publicField(_BaseAction, "DEFAULT_KEYSTORE_PATH", "./keypair.json");
+__publicField(_BaseAction, "DEFAULT_ACCOUNT_NAME", "default");
 __publicField(_BaseAction, "MAX_PASSWORD_ATTEMPTS", 3);
 __publicField(_BaseAction, "MIN_PASSWORD_LENGTH", 8);
 var BaseAction = _BaseAction;
@@ -47492,33 +47771,42 @@ var ShowAccountAction = class extends BaseAction {
   getNetwork() {
     return resolveNetwork(this.getConfig().network);
   }
-  async execute() {
+  async execute(options) {
     this.startSpinner("Fetching account info...");
     try {
-      const keypairPath = this.getConfigByKey("keyPairPath");
-      if (!keypairPath || !existsSync2(keypairPath)) {
-        this.failSpinner("No account found. Run 'genlayer account create' first.");
+      if (options?.account) {
+        this.accountOverride = options.account;
+      }
+      const accountName = this.resolveAccountName();
+      const keystorePath = this.getKeystorePath(accountName);
+      if (!existsSync2(keystorePath)) {
+        this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
         return;
       }
-      const keystoreData = JSON.parse(readFileSync3(keypairPath, "utf-8"));
+      const keystoreData = JSON.parse(readFileSync3(keystorePath, "utf-8"));
       if (!this.isValidKeystoreFormat(keystoreData)) {
         this.failSpinner("Invalid keystore format.");
         return;
       }
-      const address = keystoreData.address;
+      const rawAddr = keystoreData.address;
+      const address = rawAddr.startsWith("0x") ? rawAddr : `0x${rawAddr}`;
       const network = this.getNetwork();
       const client = createClient2({
         chain: network,
-        account: address
+        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"
+        status: isUnlocked ? "unlocked" : "locked",
+        active: isActive
       };
       this.succeedSpinner("Account info", result);
     } catch (error) {
@@ -47534,9 +47822,13 @@ var CreateAccountAction = class extends BaseAction {
   }
   async execute(options) {
     try {
-      this.startSpinner("Creating encrypted keystore...");
-      await this.createKeypair(options.output, options.overwrite);
-      this.succeedSpinner(`Account created and saved to: ${options.output}`);
+      this.startSpinner(`Creating account '${options.name}'...`);
+      await this.createKeypairByName(options.name, options.overwrite);
+      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);
     }
@@ -47545,45 +47837,86 @@ var CreateAccountAction = class extends BaseAction {
 
 // src/commands/account/import.ts
 import { ethers as ethers2 } from "ethers";
-import { writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
-var _ImportAccountAction = class _ImportAccountAction extends BaseAction {
+import { writeFileSync as writeFileSync3, existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+var ImportAccountAction = class extends BaseAction {
   constructor() {
     super();
   }
   async execute(options) {
     try {
-      const privateKey = options.privateKey || await this.promptPrivateKey();
-      const normalizedKey = this.normalizePrivateKey(privateKey);
-      this.validatePrivateKey(normalizedKey);
-      const finalOutputPath = this.getFilePath(options.output);
-      if (existsSync3(finalOutputPath) && !options.overwrite) {
-        this.failSpinner(`File at ${finalOutputPath} already exists. Use '--overwrite' to replace.`);
-      }
-      const wallet = new ethers2.Wallet(normalizedKey);
-      const 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");
+      const keystorePath = this.getKeystorePath(options.name);
+      if (existsSync3(keystorePath) && !options.overwrite) {
+        this.failSpinner(`Account '${options.name}' already exists. Use '--overwrite' to replace.`);
       }
-      if (password.length < _ImportAccountAction.MIN_PASSWORD_LENGTH) {
-        this.failSpinner(`Password must be at least ${_ImportAccountAction.MIN_PASSWORD_LENGTH} characters long`);
+      let privateKey;
+      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 ethers2.Wallet(privateKey);
+      let password;
+      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");
+        }
       }
-      this.startSpinner("Encrypting and saving keystore...");
+      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);
-      const keystoreData = {
-        version: 1,
-        encrypted: encryptedJson,
-        address: wallet.address
-      };
-      writeFileSync3(finalOutputPath, JSON.stringify(keystoreData, null, 2));
-      this.writeConfig("keyPairPath", finalOutputPath);
-      await this.keychainManager.removePrivateKey();
-      this.succeedSpinner(`Account imported and saved to: ${finalOutputPath}`);
+      writeFileSync3(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);
     }
   }
+  async importFromKeystore(keystorePath, sourcePassword) {
+    if (!existsSync3(keystorePath)) {
+      this.failSpinner(`Keystore file not found: ${keystorePath}`);
+    }
+    const fileContent = readFileSync4(keystorePath, "utf-8");
+    let encryptedJson;
+    try {
+      const parsed = JSON.parse(fileContent);
+      if (parsed.encrypted) {
+        encryptedJson = parsed.encrypted;
+      } else if (parsed.crypto || parsed.Crypto) {
+        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 ethers2.Wallet.fromEncryptedJson(encryptedJson, password);
+      this.stopSpinner();
+      return wallet.privateKey;
+    } catch {
+      this.failSpinner("Failed to decrypt keystore. Wrong password?");
+    }
+    throw new Error("Unreachable");
+  }
   async promptPrivateKey() {
     return this.promptPassword("Enter private key to import:");
   }
@@ -47597,37 +47930,110 @@ var _ImportAccountAction = class _ImportAccountAction extends BaseAction {
     }
   }
 };
-__publicField(_ImportAccountAction, "MIN_PASSWORD_LENGTH", 8);
-var ImportAccountAction = _ImportAccountAction;
 
-// src/commands/account/unlock.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+// src/commands/account/export.ts
 import { ethers as ethers3 } from "ethers";
+import { writeFileSync as writeFileSync4, existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import path4 from "path";
+var ExportAccountAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  async execute(options) {
+    try {
+      if (options.account) {
+        this.accountOverride = options.account;
+      }
+      const accountName = this.resolveAccountName();
+      const keystorePath = this.getKeystorePath(accountName);
+      if (!existsSync4(keystorePath)) {
+        this.failSpinner(`Account '${accountName}' not found.`);
+      }
+      const outputPath = path4.resolve(options.output);
+      if (existsSync4(outputPath) && !options.overwrite) {
+        this.failSpinner(`Output file already exists: ${outputPath}`);
+      }
+      const privateKey = await this.getPrivateKeyForExport(accountName, keystorePath, options.sourcePassword);
+      let password;
+      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 ethers3.Wallet(privateKey);
+      const encryptedJson = await wallet.encrypt(password);
+      writeFileSync4(outputPath, encryptedJson);
+      this.succeedSpinner(`Account '${accountName}' exported to: ${outputPath}`);
+      this.logInfo(`Address: ${wallet.address}`);
+    } catch (error) {
+      this.failSpinner("Failed to export account", error);
+    }
+  }
+  async getPrivateKeyForExport(accountName, keystorePath, sourcePassword) {
+    const isAvailable = await this.keychainManager.isKeychainAvailable();
+    if (isAvailable) {
+      const cachedKey = await this.keychainManager.getPrivateKey(accountName);
+      if (cachedKey) {
+        return cachedKey;
+      }
+    }
+    const fileContent = readFileSync5(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 ethers3.Wallet.fromEncryptedJson(encryptedJson, password);
+      this.stopSpinner();
+      return wallet.privateKey;
+    } catch {
+      this.failSpinner("Failed to decrypt keystore. Wrong password?");
+    }
+    throw new Error("Unreachable");
+  }
+};
+
+// src/commands/account/unlock.ts
+import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
+import { ethers as ethers4 } from "ethers";
 var UnlockAccountAction = class extends BaseAction {
-  async execute() {
+  async execute(options) {
     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;
     }
-    this.setSpinnerText("Checking for existing account...");
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync4(keypairPath)) {
-      this.failSpinner("No account found. Run 'genlayer account create' first.");
+    if (options?.account) {
+      this.accountOverride = options.account;
+    }
+    const accountName = this.resolveAccountName();
+    this.setSpinnerText(`Checking for account '${accountName}'...`);
+    const keystorePath = this.getKeystorePath(accountName);
+    if (!existsSync5(keystorePath)) {
+      this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
       return;
     }
-    const keystoreData = JSON.parse(readFileSync4(keypairPath, "utf-8"));
+    const keystoreJson = readFileSync6(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 account:");
-      const wallet = await ethers3.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
-      await this.keychainManager.storePrivateKey(wallet.privateKey);
-      this.succeedSpinner("Account unlocked! Private key cached in OS keychain.");
+      const password = await this.promptPassword(`Enter password to unlock '${accountName}':`);
+      const wallet = await ethers4.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);
     }
@@ -47636,23 +48042,27 @@ var UnlockAccountAction = class extends BaseAction {
 
 // src/commands/account/lock.ts
 var LockAccountAction = class extends BaseAction {
-  async execute() {
+  async execute(options) {
     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;
     }
-    this.setSpinnerText("Checking for cached private key...");
-    const hasCachedKey = await this.keychainManager.getPrivateKey();
+    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 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);
     }
@@ -47660,8 +48070,8 @@ var LockAccountAction = class extends BaseAction {
 };
 
 // src/commands/account/send.ts
-import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
-import { ethers as ethers4 } from "ethers";
+import { readFileSync as readFileSync7, existsSync as existsSync6 } from "fs";
+import { ethers as ethers5 } from "ethers";
 var SendAction = class extends BaseAction {
   constructor() {
     super();
@@ -47690,25 +48100,30 @@ var SendAction = class extends BaseAction {
   async execute(options) {
     this.startSpinner("Preparing transfer...");
     try {
-      const keypairPath = this.getConfigByKey("keyPairPath");
-      if (!keypairPath || !existsSync5(keypairPath)) {
-        this.failSpinner("No account found. Run 'genlayer account create' first.");
+      if (options.account) {
+        this.accountOverride = options.account;
+      }
+      const accountName = this.resolveAccountName();
+      const keystorePath = this.getKeystorePath(accountName);
+      if (!existsSync6(keystorePath)) {
+        this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
         return;
       }
-      const keystoreData = JSON.parse(readFileSync5(keypairPath, "utf-8"));
+      const keystoreJson = readFileSync7(keystorePath, "utf-8");
+      const keystoreData = JSON.parse(keystoreJson);
       if (!this.isValidKeystoreFormat(keystoreData)) {
         this.failSpinner("Invalid keystore format.");
         return;
       }
-      const cachedKey = await this.keychainManager.getPrivateKey();
+      const cachedKey = await this.keychainManager.getPrivateKey(accountName);
       let privateKey;
       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 ethers4.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+        const wallet = await ethers5.Wallet.fromEncryptedJson(keystoreJson, password);
         privateKey = wallet.privateKey;
       }
       const network = this.getNetwork(options.network);
@@ -47769,44 +48184,136 @@ Waiting for confirmation...`);
   }
 };
 
+// src/commands/account/list.ts
+var ListAccountsAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  async execute() {
+    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);
+    }
+  }
+};
+
+// src/commands/account/use.ts
+var UseAccountAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  async execute(name) {
+    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);
+    }
+  }
+};
+
+// src/commands/account/remove.ts
+var RemoveAccountAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  async execute(name, options) {
+    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.`);
+      }
+      await this.keychainManager.removePrivateKey(name);
+      this.removeAccount(name);
+      this.logSuccess(`Account '${name}' removed`);
+    } catch (error) {
+      this.failSpinner("Failed to remove account", error);
+    }
+  }
+};
+
 // src/commands/account/index.ts
 function initializeAccountCommands(program2) {
-  const accountCommand = program2.command("account").description("Manage your account (address, balance, keys)").action(async () => {
+  const accountCommand = program2.command("account").description("Manage your accounts (address, balance, keys)").action(async () => {
+    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) => {
     const showAction = new ShowAccountAction();
-    await showAction.execute();
+    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).action(async (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) => {
     const createAction = new CreateAccountAction();
     await createAction.execute(options);
   });
-  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).action(async (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) => {
     const importAction = new ImportAccountAction();
     await importAction.execute(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, amount, 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) => {
+    const exportAction = new ExportAccountAction();
+    await exportAction.execute(options);
+  });
+  accountCommand.command("use <name>").description("Set the active account").action(async (name) => {
+    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, options) => {
+    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, amount, options) => {
     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 () => {
+  accountCommand.command("unlock").description("Unlock account by caching private key in OS keychain").option("--account <name>", "Account to unlock").action(async (options) => {
     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 () => {
+  accountCommand.command("lock").description("Lock account by removing private key from OS keychain").option("--account <name>", "Account to lock").action(async (options) => {
     const lockAction = new LockAccountAction();
-    await lockAction.execute();
+    await lockAction.execute(options);
   });
   return program2;
 }
 
 // src/commands/contracts/deploy.ts
 import fs9 from "fs";
-import path4 from "path";
+import path5 from "path";
 import { pathToFileURL } from "url";
 import { buildSync } from "esbuild";
 var DeployAction = class extends BaseAction {
   constructor() {
     super();
-    __publicField(this, "deployDir", path4.resolve(process.cwd(), "deploy"));
+    __publicField(this, "deployDir", path5.resolve(process.cwd(), "deploy"));
   }
   readContractCode(contractPath) {
     if (!fs9.existsSync(contractPath)) {
@@ -47869,7 +48376,7 @@ var DeployAction = class extends BaseAction {
     }
     this.setSpinnerText(`Found ${files.length} deploy scripts. Executing...`);
     for (const file of files) {
-      const filePath = path4.resolve(this.deployDir, file);
+      const filePath = path5.resolve(this.deployDir, file);
       this.setSpinnerText(`Executing script: ${filePath}`);
       try {
         if (file.endsWith(".ts")) {
@@ -48388,18 +48895,18 @@ function initializeUpdateCommands(program2) {
 
 // src/commands/scaffold/new.ts
 import fs10 from "fs-extra";
-import path5 from "path";
+import path6 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var NewAction = class extends BaseAction {
   constructor() {
     super();
     __publicField(this, "templatePath");
     const __filename = fileURLToPath3(import.meta.url);
-    const basePath = path5.resolve(path5.dirname(__filename), "..");
-    this.templatePath = path5.join(basePath, "templates", "default");
+    const basePath = path6.resolve(path6.dirname(__filename), "..");
+    this.templatePath = path6.join(basePath, "templates", "default");
   }
   async createProject(projectName, options) {
-    const targetPath = path5.resolve(options.path, projectName);
+    const targetPath = path6.resolve(options.path, projectName);
     if (fs10.existsSync(targetPath) && !options.overwrite) {
       return this.failSpinner(
         `Project directory "${targetPath}" already exists. Use --overwrite to replace it.`
@@ -48426,27 +48933,40 @@ function initializeScaffoldCommands(program2) {
 
 // src/commands/network/setNetwork.ts
 import inquirer5 from "inquirer";
-var networks2 = [
-  {
-    name: localnet.name,
-    alias: "localnet",
-    value: localnet
-  },
-  {
-    name: studionet.name,
-    alias: "studionet",
-    value: studionet
-  },
-  {
-    name: testnetAsimov.name,
-    alias: "testnet-asimov",
-    value: testnetAsimov
-  }
-];
+var networks2 = Object.entries(BUILT_IN_NETWORKS).map(([alias, network]) => ({
+  name: network.name,
+  alias,
+  value: network
+}));
 var NetworkActions = class extends BaseAction {
   constructor() {
     super();
   }
+  async showInfo() {
+    const storedNetwork = this.getConfigByKey("network") || "localnet";
+    const network = resolveNetwork(storedNetwork);
+    const info = {
+      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() {
+    const currentNetwork = this.getConfigByKey("network") || "localnet";
+    console.log("");
+    for (const net of networks2) {
+      const marker = net.alias === currentNetwork ? "*" : " ";
+      console.log(`${marker} ${net.alias.padEnd(16)} ${net.name}`);
+    }
+    console.log("");
+  }
   async setNetwork(networkName) {
     if (networkName || networkName === "") {
       if (!networks2.some((n) => n.name === networkName || n.alias === networkName)) {
@@ -48481,7 +49001,10 @@ var NetworkActions = class extends BaseAction {
 // src/commands/network/index.ts
 function initializeNetworkCommands(program2) {
   const networkActions = new NetworkActions();
-  program2.command("network").description("Set the network to use").argument("[network]", "The network to use").action((networkName) => networkActions.setNetwork(networkName));
+  const network = program2.command("network").description("Network configuration");
+  network.command("set").description("Set the network to use").argument("[network]", "The network to set").action((networkName) => networkActions.setNetwork(networkName));
+  network.command("info").description("Show current network configuration and contract addresses").action(() => networkActions.showInfo());
+  network.command("list").description("List available networks").action(() => networkActions.listNetworks());
   return program2;
 }
 
@@ -48595,8 +49118,8 @@ function initializeTransactionsCommands(program2) {
 }
 
 // src/commands/staking/StakingAction.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
-import { ethers as ethers5 } from "ethers";
+import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
+import { ethers as ethers6 } from "ethers";
 var StakingAction = class extends BaseAction {
   constructor() {
     super();
@@ -48614,6 +49137,9 @@ var StakingAction = class extends BaseAction {
   }
   async getStakingClient(config) {
     if (!this._stakingClient) {
+      if (config.account) {
+        this.accountOverride = config.account;
+      }
       const network = this.getNetwork(config);
       if (config.stakingAddress) {
         network.stakingContract = {
@@ -48632,6 +49158,9 @@ var StakingAction = class extends BaseAction {
     return this._stakingClient;
   }
   async getReadOnlyStakingClient(config) {
+    if (config.account) {
+      this.accountOverride = config.account;
+    }
     const network = this.getNetwork(config);
     if (config.stakingAddress) {
       network.stakingContract = {
@@ -48639,34 +49168,46 @@ var StakingAction = class extends BaseAction {
         abi: abi_exports.STAKING_ABI
       };
     }
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync6(keypairPath)) {
-      throw new Error("No account found. Run 'genlayer account create' first.");
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
+    if (!existsSync7(keystorePath)) {
+      throw new Error(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
     }
-    const keystoreData = JSON.parse(readFileSync6(keypairPath, "utf-8"));
+    const keystoreData = JSON.parse(readFileSync8(keystorePath, "utf-8"));
+    const addr = keystoreData.address;
+    const normalizedAddress = addr.startsWith("0x") ? addr : `0x${addr}`;
     return createClient2({
       chain: network,
       endpoint: config.rpc,
-      account: keystoreData.address
+      account: normalizedAddress
     });
   }
   async getPrivateKeyForStaking() {
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync6(keypairPath)) {
-      throw new Error("No account found. Run 'genlayer account create' first.");
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
+    if (!existsSync7(keystorePath)) {
+      throw new Error(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
     }
-    const keystoreData = JSON.parse(readFileSync6(keypairPath, "utf-8"));
+    const keystoreJson = readFileSync8(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;
+      const tempAccount = createAccount(cachedKey);
+      const cachedAddress = tempAccount.address.toLowerCase();
+      const keystoreAddress = `0x${keystoreData.address.toLowerCase().replace(/^0x/, "")}`;
+      if (cachedAddress !== keystoreAddress) {
+        await this.keychainManager.removePrivateKey(accountName);
+      } else {
+        return cachedKey;
+      }
     }
     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 ethers5.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+    const wallet = await ethers6.Wallet.fromEncryptedJson(keystoreJson, password);
     return wallet.privateKey;
   }
   parseAmount(amount) {
@@ -48676,12 +49217,14 @@ var StakingAction = class extends BaseAction {
     return formatStakingAmount(amount);
   }
   async getSignerAddress() {
-    const keypairPath = this.getConfigByKey("keyPairPath");
-    if (!keypairPath || !existsSync6(keypairPath)) {
-      throw new Error("Keypair file not found.");
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
+    if (!existsSync7(keystorePath)) {
+      throw new Error(`Account '${accountName}' not found.`);
     }
-    const keystoreData = JSON.parse(readFileSync6(keypairPath, "utf-8"));
-    return keystoreData.address;
+    const keystoreData = JSON.parse(readFileSync8(keystorePath, "utf-8"));
+    const addr = keystoreData.address;
+    return addr.startsWith("0x") ? addr : `0x${addr}`;
   }
 };
 
@@ -48886,9 +49429,14 @@ var SetIdentityAction = class extends StakingAction {
         blockNumber: result.blockNumber.toString(),
         gasUsed: result.gasUsed.toString()
       };
+      if (options.logoUri) output.logoUri = options.logoUri;
       if (options.website) output.website = options.website;
+      if (options.description) output.description = options.description;
+      if (options.email) output.email = options.email;
       if (options.twitter) output.twitter = options.twitter;
+      if (options.telegram) output.telegram = options.telegram;
       if (options.github) output.github = options.github;
+      if (options.extraCid) output.extraCid = options.extraCid;
       this.succeedSpinner("Validator identity set!", output);
     } catch (error) {
       this.failSpinner("Failed to set identity", error.message || error);
@@ -48920,6 +49468,8 @@ var DelegatorJoinAction = class extends StakingAction {
         gasUsed: result.gasUsed.toString()
       };
       this.succeedSpinner("Successfully joined as delegator!", output);
+      console.log(source_default.dim(`
+To view your delegation: genlayer staking delegation-info --validator ${options.validator}`));
     } catch (error) {
       this.failSpinner("Failed to join as delegator", error.message || error);
     }
@@ -48993,6 +49543,8 @@ var DelegatorClaimAction = class extends StakingAction {
 };
 
 // src/commands/staking/stakingInfo.ts
+var ACTIVATION_DELAY_EPOCHS = 2n;
+var UNBONDING_PERIOD_EPOCHS = 7n;
 var StakingInfoAction = class extends StakingAction {
   constructor() {
     super();
@@ -49026,21 +49578,24 @@ var StakingInfoAction = class extends StakingAction {
         needsPriming: info.needsPriming,
         live: info.live,
         banned: info.banned ? info.bannedEpoch?.toString() : "Not banned",
-        selfStakePendingDeposits: info.pendingDeposits.length > 0 ? info.pendingDeposits.map((d) => {
-          const depositEpoch = d.epoch;
-          const activationEpoch = depositEpoch + 2n;
-          const epochsUntilActive = activationEpoch - currentEpoch;
-          return {
-            epoch: depositEpoch.toString(),
-            stake: d.stake,
-            shares: d.shares.toString(),
-            activatesAtEpoch: activationEpoch.toString(),
-            status: epochsUntilActive <= 0n ? "Active" : `Pending (${epochsUntilActive} epoch${epochsUntilActive > 1n ? "s" : ""} remaining)`
-          };
-        }) : "None",
+        selfStakePendingDeposits: (() => {
+          const pending = info.pendingDeposits.filter((d) => d.epoch + ACTIVATION_DELAY_EPOCHS > currentEpoch);
+          return pending.length > 0 ? pending.map((d) => {
+            const depositEpoch = d.epoch;
+            const activationEpoch = depositEpoch + ACTIVATION_DELAY_EPOCHS;
+            const epochsUntilActive = activationEpoch - currentEpoch;
+            return {
+              epoch: depositEpoch.toString(),
+              stake: d.stake,
+              shares: d.shares.toString(),
+              activatesAtEpoch: activationEpoch.toString(),
+              epochsRemaining: epochsUntilActive.toString()
+            };
+          }) : "None";
+        })(),
         selfStakePendingWithdrawals: info.pendingWithdrawals.length > 0 ? info.pendingWithdrawals.map((w) => {
           const exitEpoch = w.epoch;
-          const claimableEpoch = exitEpoch + 7n;
+          const claimableEpoch = exitEpoch + UNBONDING_PERIOD_EPOCHS;
           const epochsUntilClaimable = claimableEpoch - currentEpoch;
           return {
             epoch: exitEpoch.toString(),
@@ -49073,6 +49628,8 @@ var StakingInfoAction = class extends StakingAction {
     try {
       const client = await this.getReadOnlyStakingClient(options);
       const delegatorAddress = options.delegator || await this.getSignerAddress();
+      const isOwnDelegation = !options.delegator;
+      this.setSpinnerText(`Fetching delegation info for ${delegatorAddress}...`);
       if (!options.validator) {
         this.failSpinner("Validator address is required");
         return;
@@ -49095,21 +49652,24 @@ var StakingInfoAction = class extends StakingAction {
         shares: info.shares.toString(),
         stake: info.stake,
         projectedReward,
-        pendingDeposits: info.pendingDeposits.length > 0 ? info.pendingDeposits.map((d) => {
-          const depositEpoch = d.epoch;
-          const activationEpoch = depositEpoch + 2n;
-          const epochsUntilActive = activationEpoch - currentEpoch;
-          return {
-            epoch: depositEpoch.toString(),
-            stake: d.stake,
-            shares: d.shares.toString(),
-            activatesAtEpoch: activationEpoch.toString(),
-            status: epochsUntilActive <= 0n ? "Active" : `Pending (${epochsUntilActive} epoch${epochsUntilActive > 1n ? "s" : ""} remaining)`
-          };
-        }) : "None",
+        pendingDeposits: (() => {
+          const pending = info.pendingDeposits.filter((d) => d.epoch + ACTIVATION_DELAY_EPOCHS > currentEpoch);
+          return pending.length > 0 ? pending.map((d) => {
+            const depositEpoch = d.epoch;
+            const activationEpoch = depositEpoch + ACTIVATION_DELAY_EPOCHS;
+            const epochsUntilActive = activationEpoch - currentEpoch;
+            return {
+              epoch: depositEpoch.toString(),
+              stake: d.stake,
+              shares: d.shares.toString(),
+              activatesAtEpoch: activationEpoch.toString(),
+              epochsRemaining: epochsUntilActive.toString()
+            };
+          }) : "None";
+        })(),
         pendingWithdrawals: info.pendingWithdrawals.length > 0 ? info.pendingWithdrawals.map((w) => {
           const exitEpoch = w.epoch;
-          const claimableEpoch = exitEpoch + 7n;
+          const claimableEpoch = exitEpoch + UNBONDING_PERIOD_EPOCHS;
           const epochsUntilClaimable = claimableEpoch - currentEpoch;
           return {
             epoch: exitEpoch.toString(),
@@ -49120,7 +49680,8 @@ var StakingInfoAction = class extends StakingAction {
           };
         }) : "None"
       };
-      this.succeedSpinner("Stake info retrieved", result);
+      const msg = isOwnDelegation ? "Your delegation info" : `Delegation info for ${delegatorAddress}`;
+      this.succeedSpinner(msg, result);
     } catch (error) {
       this.failSpinner("Failed to get stake info", error.message || error);
     }
@@ -49214,54 +49775,696 @@ var StakingInfoAction = class extends StakingAction {
   }
 };
 
+// src/commands/staking/wizard.ts
+import inquirer6 from "inquirer";
+import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
+import path7 from "path";
+function ensureHexPrefix(address) {
+  if (!address) return address;
+  return address.startsWith("0x") ? address : `0x${address}`;
+}
+var ValidatorWizardAction = class extends StakingAction {
+  constructor() {
+    super();
+  }
+  async execute(options) {
+    console.log("\n========================================");
+    console.log("   GenLayer Validator Setup Wizard");
+    console.log("========================================\n");
+    const state = {};
+    try {
+      await this.stepAccountSetup(state, options);
+      await this.stepNetworkSelection(state, options);
+      await this.stepBalanceCheck(state, options);
+      await this.stepOperatorSetup(state);
+      await this.stepStakeAmount(state);
+      await this.stepJoinValidator(state, options);
+      if (!options.skipIdentity) {
+        await this.stepIdentitySetup(state, options);
+      }
+      this.showSummary(state);
+    } catch (error) {
+      if (error.message === "WIZARD_ABORTED") {
+        this.logError("Wizard aborted.");
+        return;
+      }
+      this.failSpinner("Wizard failed", error.message || error);
+    }
+  }
+  async stepAccountSetup(state, options) {
+    console.log("Step 1: Account Setup");
+    console.log("---------------------\n");
+    if (options.account) {
+      const keystorePath = this.getKeystorePath(options.account);
+      if (!this.accountExists(options.account)) {
+        this.failSpinner(`Account '${options.account}' not found.`);
+      }
+      state.accountName = options.account;
+      this.accountOverride = options.account;
+      const address = await this.getSignerAddress();
+      state.accountAddress = ensureHexPrefix(address);
+      console.log(`Using account: ${options.account} (${state.accountAddress})
+`);
+      return;
+    }
+    const accounts = this.listAccounts();
+    if (accounts.length === 0) {
+      console.log("No accounts found. Let's create one.\n");
+      const { accountName } = await inquirer6.prompt([
+        {
+          type: "input",
+          name: "accountName",
+          message: "Enter a name for your validator account:",
+          default: "validator",
+          validate: (input) => input.length > 0 || "Name cannot be empty"
+        }
+      ]);
+      const createAction = new CreateAccountAction();
+      await createAction.execute({ name: accountName, overwrite: false, setActive: true });
+      state.accountName = accountName;
+      this.accountOverride = accountName;
+      const address = await this.getSignerAddress();
+      state.accountAddress = ensureHexPrefix(address);
+    } else {
+      const choices = [
+        ...accounts.map((a) => ({
+          name: `${a.name} (${a.address})`,
+          value: a.name
+        })),
+        { name: "Create new account", value: "__create_new__" }
+      ];
+      const { selectedAccount } = await inquirer6.prompt([
+        {
+          type: "list",
+          name: "selectedAccount",
+          message: "Select an account that will be the owner of the validator:",
+          choices
+        }
+      ]);
+      if (selectedAccount === "__create_new__") {
+        const { accountName } = await inquirer6.prompt([
+          {
+            type: "input",
+            name: "accountName",
+            message: "Enter a name for your validator account:",
+            default: "validator",
+            validate: (input) => {
+              if (input.length === 0) return "Name cannot be empty";
+              if (accounts.find((a) => a.name === input)) return "Account with this name already exists";
+              return true;
+            }
+          }
+        ]);
+        const createAction = new CreateAccountAction();
+        await createAction.execute({ name: accountName, overwrite: false, setActive: true });
+        state.accountName = accountName;
+        this.accountOverride = accountName;
+        const address = await this.getSignerAddress();
+        state.accountAddress = ensureHexPrefix(address);
+      } else {
+        state.accountName = selectedAccount;
+        this.accountOverride = selectedAccount;
+        this.setActiveAccount(selectedAccount);
+        const address = await this.getSignerAddress();
+        state.accountAddress = ensureHexPrefix(address);
+        console.log(`
+Using account: ${selectedAccount} (${state.accountAddress})`);
+      }
+    }
+    console.log("");
+  }
+  async stepNetworkSelection(state, options) {
+    console.log("Step 2: Network Selection");
+    console.log("-------------------------\n");
+    if (options.network) {
+      const network = BUILT_IN_NETWORKS[options.network];
+      if (!network) {
+        this.failSpinner(`Unknown network: ${options.network}`);
+      }
+      state.networkAlias = options.network;
+      this.writeConfig("network", options.network);
+      console.log(`Using network: ${network.name}
+`);
+      return;
+    }
+    const currentNetwork = this.getConfigByKey("network");
+    const excludedNetworks = ["studionet"];
+    const networks3 = Object.entries(BUILT_IN_NETWORKS).filter(([alias]) => !excludedNetworks.includes(alias)).map(([alias, chain]) => ({
+      name: chain.name,
+      value: alias
+    }));
+    const { selectedNetwork } = await inquirer6.prompt([
+      {
+        type: "list",
+        name: "selectedNetwork",
+        message: "Select network:",
+        choices: networks3,
+        default: currentNetwork || "testnet-asimov"
+      }
+    ]);
+    state.networkAlias = selectedNetwork;
+    this.writeConfig("network", selectedNetwork);
+    console.log(`
+Network set to: ${BUILT_IN_NETWORKS[selectedNetwork].name}
+`);
+  }
+  async stepBalanceCheck(state, options) {
+    console.log("Step 3: Balance Check");
+    console.log("---------------------\n");
+    this.startSpinner("Checking balance and staking requirements...");
+    const network = BUILT_IN_NETWORKS[state.networkAlias];
+    const client = createClient2({
+      chain: network,
+      account: state.accountAddress,
+      endpoint: options.rpc
+    });
+    const [balance, epochInfo] = await Promise.all([
+      client.getBalance({ address: state.accountAddress }),
+      client.getEpochInfo()
+    ]);
+    this.stopSpinner();
+    const balanceFormatted = formatEther(balance);
+    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, but gas fees still required)");
+      console.log(`Note: Validator won't become active until self-stake reaches ${minStakeFormatted}`);
+    }
+    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 ${minFormatted} to become a validator.
+Fund your account (${state.accountAddress}) and run the wizard again.`
+      );
+    }
+    state.balance = balance;
+    state.minStake = currentEpoch === 0n ? 0n : minStakeRaw;
+    console.log("Balance sufficient!\n");
+  }
+  async stepOperatorSetup(state) {
+    console.log("Step 4: Operator Setup");
+    console.log("----------------------\n");
+    console.log("Using a separate operator address is recommended for security:");
+    console.log("- Owner account: holds staked funds (keep secure)");
+    console.log("- Operator account: signs blocks (hot wallet on validator server)\n");
+    const { useOperator } = await inquirer6.prompt([
+      {
+        type: "confirm",
+        name: "useOperator",
+        message: "Do you want to use a separate operator address?",
+        default: true
+      }
+    ]);
+    if (!useOperator) {
+      state.operatorAddress = ensureHexPrefix(state.accountAddress);
+      state.operatorAccountName = state.accountName;
+      console.log("\nOperator will be the same as owner address.\n");
+      return;
+    }
+    const accounts = this.listAccounts();
+    const otherAccounts = accounts.filter((a) => a.name !== state.accountName);
+    const choices = [
+      { name: "Create new operator account", value: "create" },
+      ...otherAccounts.length > 0 ? [{ name: "Select from my accounts", value: "select" }] : [],
+      { name: "Enter existing operator address", value: "existing" }
+    ];
+    const { operatorChoice } = await inquirer6.prompt([
+      {
+        type: "list",
+        name: "operatorChoice",
+        message: "How would you like to set up the operator?",
+        choices
+      }
+    ]);
+    if (operatorChoice === "existing") {
+      const { operatorAddress } = await inquirer6.prompt([
+        {
+          type: "input",
+          name: "operatorAddress",
+          message: "Enter operator address (0x...):",
+          validate: (input) => {
+            if (!input.match(/^0x[a-fA-F0-9]{40}$/)) {
+              return "Invalid address format. Expected 0x followed by 40 hex characters.";
+            }
+            return true;
+          }
+        }
+      ]);
+      state.operatorAddress = ensureHexPrefix(operatorAddress);
+      console.log("");
+      return;
+    }
+    if (operatorChoice === "select") {
+      const { selectedOperator } = await inquirer6.prompt([
+        {
+          type: "list",
+          name: "selectedOperator",
+          message: "Select an account to use as operator:",
+          choices: otherAccounts.map((a) => ({
+            name: `${a.name} (${a.address})`,
+            value: a.name
+          }))
+        }
+      ]);
+      const operatorKeystorePath2 = this.getKeystorePath(selectedOperator);
+      const operatorData2 = JSON.parse(readFileSync9(operatorKeystorePath2, "utf-8"));
+      state.operatorAddress = ensureHexPrefix(operatorData2.address);
+      state.operatorAccountName = selectedOperator;
+      const defaultFilename2 = `${selectedOperator}-keystore.json`;
+      const { outputFilename: outputFilename2 } = await inquirer6.prompt([
+        {
+          type: "input",
+          name: "outputFilename",
+          message: "Export keystore filename:",
+          default: defaultFilename2
+        }
+      ]);
+      let outputPath2 = path7.resolve(`./${outputFilename2}`);
+      if (existsSync8(outputPath2)) {
+        const { overwrite } = await inquirer6.prompt([
+          {
+            type: "confirm",
+            name: "overwrite",
+            message: `File ${outputFilename2} already exists. Overwrite?`,
+            default: false
+          }
+        ]);
+        if (!overwrite) {
+          const { newFilename } = await inquirer6.prompt([
+            {
+              type: "input",
+              name: "newFilename",
+              message: "Enter new filename:"
+            }
+          ]);
+          outputPath2 = path7.resolve(`./${newFilename}`);
+        }
+      }
+      const { exportPassword: exportPassword2 } = await inquirer6.prompt([
+        {
+          type: "password",
+          name: "exportPassword",
+          message: "Enter password for exported keystore (needed to import in node):",
+          mask: "*",
+          validate: (input) => input.length >= 8 || "Password must be at least 8 characters"
+        }
+      ]);
+      const { confirmPassword: confirmPassword2 } = await inquirer6.prompt([
+        {
+          type: "password",
+          name: "confirmPassword",
+          message: "Confirm password:",
+          mask: "*"
+        }
+      ]);
+      if (exportPassword2 !== confirmPassword2) {
+        this.failSpinner("Passwords do not match");
+      }
+      const exportAction2 = new ExportAccountAction();
+      await exportAction2.execute({
+        account: selectedOperator,
+        output: outputPath2,
+        password: exportPassword2,
+        overwrite: true
+      });
+      state.operatorKeystorePath = outputPath2;
+      console.log("\n========================================");
+      console.log("  IMPORTANT: Transfer operator keystore");
+      console.log("========================================");
+      console.log(`File: ${outputPath2}`);
+      console.log("Transfer this file to your validator server and import it");
+      console.log("into your validator node software.");
+      console.log("========================================\n");
+      return;
+    }
+    const { operatorName } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "operatorName",
+        message: "Enter a name for the operator account:",
+        default: "operator",
+        validate: (input) => {
+          if (input.length === 0) return "Name cannot be empty";
+          if (accounts.find((a) => a.name === input)) return "Account with this name already exists";
+          return true;
+        }
+      }
+    ]);
+    console.log("");
+    const createAction = new CreateAccountAction();
+    await createAction.execute({ name: operatorName, overwrite: false, setActive: false });
+    const operatorKeystorePath = this.getKeystorePath(operatorName);
+    const operatorData = JSON.parse(readFileSync9(operatorKeystorePath, "utf-8"));
+    state.operatorAddress = ensureHexPrefix(operatorData.address);
+    state.operatorAccountName = operatorName;
+    const defaultFilename = `${operatorName}-keystore.json`;
+    const { outputFilename } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "outputFilename",
+        message: "Export keystore filename:",
+        default: defaultFilename
+      }
+    ]);
+    let outputPath = path7.resolve(`./${outputFilename}`);
+    if (existsSync8(outputPath)) {
+      const { overwrite } = await inquirer6.prompt([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: `File ${outputFilename} already exists. Overwrite?`,
+          default: false
+        }
+      ]);
+      if (!overwrite) {
+        const { newFilename } = await inquirer6.prompt([
+          {
+            type: "input",
+            name: "newFilename",
+            message: "Enter new filename:"
+          }
+        ]);
+        outputPath = path7.resolve(`./${newFilename}`);
+      }
+    }
+    const { exportPassword } = await inquirer6.prompt([
+      {
+        type: "password",
+        name: "exportPassword",
+        message: "Enter password for exported keystore (needed to import in node):",
+        mask: "*",
+        validate: (input) => input.length >= 8 || "Password must be at least 8 characters"
+      }
+    ]);
+    const { confirmPassword } = await inquirer6.prompt([
+      {
+        type: "password",
+        name: "confirmPassword",
+        message: "Confirm password:",
+        mask: "*"
+      }
+    ]);
+    if (exportPassword !== confirmPassword) {
+      this.failSpinner("Passwords do not match");
+    }
+    const exportAction = new ExportAccountAction();
+    await exportAction.execute({
+      account: operatorName,
+      output: outputPath,
+      password: exportPassword,
+      overwrite: true
+    });
+    state.operatorKeystorePath = outputPath;
+    console.log("\n========================================");
+    console.log("  IMPORTANT: Transfer operator keystore");
+    console.log("========================================");
+    console.log(`File: ${outputPath}`);
+    console.log("Transfer this file to your validator server and import it");
+    console.log("into your validator node software.");
+    console.log("========================================\n");
+  }
+  async stepStakeAmount(state) {
+    console.log("Step 5: Stake Amount");
+    console.log("--------------------\n");
+    const balanceGEN = formatEther(state.balance);
+    const minStakeGEN = formatEther(state.minStake);
+    const hasMinStake = state.minStake > 0n;
+    const { stakeAmount } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "stakeAmount",
+        message: hasMinStake ? `Enter stake amount (min: ${minStakeGEN}, max: ${balanceGEN} GEN):` : `Enter stake amount (max: ${balanceGEN} GEN):`,
+        default: hasMinStake ? minStakeGEN : "1",
+        validate: (input) => {
+          const cleaned = input.toLowerCase().replace("gen", "").trim();
+          const num2 = parseFloat(cleaned);
+          if (isNaN(num2) || num2 <= 0) {
+            return "Please enter a valid positive number";
+          }
+          const amountWei = BigInt(Math.floor(num2 * 1e18));
+          if (hasMinStake && amountWei < state.minStake) {
+            return `Amount must be at least ${minStakeGEN} GEN`;
+          }
+          if (amountWei > state.balance) {
+            return `Amount exceeds balance (${balanceGEN} GEN)`;
+          }
+          return true;
+        }
+      }
+    ]);
+    const normalizedAmount = stakeAmount.toLowerCase().endsWith("gen") ? stakeAmount : `${stakeAmount}gen`;
+    state.stakeAmount = normalizedAmount;
+    const { confirm } = await inquirer6.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `You will stake ${stakeAmount}. Continue?`,
+        default: true
+      }
+    ]);
+    if (!confirm) {
+      throw new Error("WIZARD_ABORTED");
+    }
+    console.log("");
+  }
+  async stepJoinValidator(state, options) {
+    console.log("Step 6: Join as Validator");
+    console.log("-------------------------\n");
+    this.startSpinner("Creating validator...");
+    try {
+      const client = await this.getStakingClient({
+        ...options,
+        account: state.accountName,
+        network: state.networkAlias
+      });
+      const amount = this.parseAmount(state.stakeAmount);
+      this.setSpinnerText(`Creating validator with ${this.formatAmount(amount)} stake...`);
+      const result = await client.validatorJoin({
+        amount,
+        operator: state.operatorAddress
+      });
+      state.validatorWalletAddress = ensureHexPrefix(result.validatorWallet);
+      this.succeedSpinner("Validator created successfully!", {
+        transactionHash: result.transactionHash,
+        validatorWallet: state.validatorWalletAddress,
+        amount: result.amount,
+        operator: result.operator,
+        blockNumber: result.blockNumber.toString()
+      });
+      console.log("");
+    } catch (error) {
+      this.failSpinner("Failed to create validator", error.message || error);
+    }
+  }
+  async stepIdentitySetup(state, options) {
+    console.log("Step 7: Identity Setup");
+    console.log("----------------------\n");
+    const { setupIdentity } = await inquirer6.prompt([
+      {
+        type: "confirm",
+        name: "setupIdentity",
+        message: "Would you like to set up your validator identity now?",
+        default: true
+      }
+    ]);
+    if (!setupIdentity) {
+      console.log("\nYou can set up identity later with: genlayer staking set-identity\n");
+      return;
+    }
+    const { moniker } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "moniker",
+        message: "Enter validator display name (moniker):",
+        validate: (input) => input.length > 0 || "Moniker is required"
+      }
+    ]);
+    const { logoUri } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "logoUri",
+        message: "Enter logo URL (optional):"
+      }
+    ]);
+    const { website } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "website",
+        message: "Enter website URL (optional):"
+      }
+    ]);
+    const { description } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "description",
+        message: "Enter description (optional):"
+      }
+    ]);
+    const { email } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "email",
+        message: "Enter contact email (optional):"
+      }
+    ]);
+    const { twitter } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "twitter",
+        message: "Enter Twitter handle (optional):"
+      }
+    ]);
+    const { telegram } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "telegram",
+        message: "Enter Telegram handle (optional):"
+      }
+    ]);
+    const { github } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "github",
+        message: "Enter GitHub handle (optional):"
+      }
+    ]);
+    state.identity = {
+      moniker,
+      logoUri: logoUri || void 0,
+      website: website || void 0,
+      description: description || void 0,
+      email: email || void 0,
+      twitter: twitter || void 0,
+      telegram: telegram || void 0,
+      github: github || void 0
+    };
+    this.startSpinner("Setting validator identity...");
+    try {
+      const client = await this.getStakingClient({
+        ...options,
+        account: state.accountName,
+        network: state.networkAlias
+      });
+      const validatorAddress = state.validatorWalletAddress || state.accountAddress;
+      await client.setIdentity({
+        validator: ensureHexPrefix(validatorAddress),
+        moniker,
+        logoUri: logoUri || void 0,
+        website: website || void 0,
+        description: description || void 0,
+        email: email || void 0,
+        twitter: twitter || void 0,
+        telegram: telegram || void 0,
+        github: github || void 0
+      });
+      this.succeedSpinner("Validator identity set!");
+      console.log("");
+    } catch (error) {
+      this.stopSpinner();
+      this.logWarning(`Failed to set identity: ${error.message || error}`);
+      console.log("You can try again later with: genlayer staking set-identity\n");
+    }
+  }
+  showSummary(state) {
+    console.log("\n========================================");
+    console.log("   Validator Setup Complete!");
+    console.log("========================================\n");
+    const validatorWallet = ensureHexPrefix(state.validatorWalletAddress || state.accountAddress);
+    const ownerAddress = ensureHexPrefix(state.accountAddress);
+    const operatorAddress = ensureHexPrefix(state.operatorAddress || "");
+    console.log("Summary:");
+    console.log(`  Validator Wallet:  ${validatorWallet}`);
+    console.log(`  Owner:             ${ownerAddress} (${state.accountName})`);
+    if (state.operatorAccountName) {
+      console.log(`  Operator:          ${operatorAddress} (${state.operatorAccountName})`);
+    } else {
+      console.log(`  Operator:          ${operatorAddress}`);
+    }
+    console.log(`  Staked Amount:     ${state.stakeAmount}`);
+    console.log(`  Network:           ${BUILT_IN_NETWORKS[state.networkAlias].name}`);
+    if (state.identity) {
+      console.log(`  Identity:`);
+      console.log(`    Moniker: ${state.identity.moniker}`);
+      if (state.identity.logoUri) console.log(`    Logo: ${state.identity.logoUri}`);
+      if (state.identity.website) console.log(`    Website: ${state.identity.website}`);
+      if (state.identity.description) console.log(`    Description: ${state.identity.description}`);
+      if (state.identity.email) console.log(`    Email: ${state.identity.email}`);
+      if (state.identity.twitter) console.log(`    Twitter: ${state.identity.twitter}`);
+      if (state.identity.telegram) console.log(`    Telegram: ${state.identity.telegram}`);
+      if (state.identity.github) console.log(`    GitHub: ${state.identity.github}`);
+    }
+    console.log("\nNext Steps:");
+    let step = 1;
+    if (state.operatorKeystorePath) {
+      console.log(`  ${step++}. Transfer operator keystore to your validator server:`);
+      console.log(`     ${state.operatorKeystorePath}`);
+      console.log(`  ${step++}. Import it into your validator node software`);
+    }
+    console.log(`  ${step++}. Monitor your validator:`);
+    console.log(`     genlayer staking validator-info --validator ${validatorWallet}`);
+    console.log(`  ${step++}. Lock your account when done: genlayer account lock`);
+    console.log("\n========================================\n");
+  }
+};
+
 // src/commands/staking/index.ts
 function initializeStakingCommands(program2) {
   const staking = program2.command("staking").description("Staking operations for validators and delegators");
-  staking.command("validator-join").description("Join as a validator by staking tokens").requiredOption("--amount <amount>", "Amount to stake (in wei or with 'eth'/'gen' suffix, e.g., '42000gen')").option("--operator <address>", "Operator address (defaults to signer)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("wizard").description("Interactive wizard to become a validator").option("--account <name>", "Account to use (skip selection)").option("--network <network>", "Network to use (skip selection)").option("--skip-identity", "Skip identity setup step").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+    const wizard = new ValidatorWizardAction();
+    await wizard.execute(options);
+  });
+  staking.command("validator-join").description("Join as a validator by staking tokens").requiredOption("--amount <amount>", "Amount to stake (in wei or with 'eth'/'gen' suffix, e.g., '42000gen')").option("--operator <address>", "Operator address (defaults to signer)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new ValidatorJoinAction();
     await action.execute(options);
   });
-  staking.command("validator-deposit").description("Make an additional deposit as a validator").requiredOption("--amount <amount>", "Amount to deposit (in wei or with 'eth'/'gen' suffix)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("validator-deposit").description("Make an additional deposit as a validator").requiredOption("--amount <amount>", "Amount to deposit (in wei or with 'eth'/'gen' suffix)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new ValidatorDepositAction();
     await action.execute(options);
   });
-  staking.command("validator-exit").description("Exit as a validator by withdrawing shares").requiredOption("--shares <shares>", "Number of shares to withdraw").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("validator-exit").description("Exit as a validator by withdrawing shares").requiredOption("--shares <shares>", "Number of shares to withdraw").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new ValidatorExitAction();
     await action.execute(options);
   });
-  staking.command("validator-claim").description("Claim validator withdrawals after unbonding period").option("--validator <address>", "Validator address (defaults to signer)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("validator-claim").description("Claim validator withdrawals after unbonding period").option("--validator <address>", "Validator address (defaults to signer)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new ValidatorClaimAction();
     await action.execute(options);
   });
-  staking.command("validator-prime").description("Prime a validator to prepare their stake record for the next epoch").requiredOption("--validator <address>", "Validator address to prime").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("validator-prime").description("Prime a validator to prepare their stake record for the next epoch").requiredOption("--validator <address>", "Validator address to prime").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new ValidatorPrimeAction();
     await action.execute(options);
   });
-  staking.command("set-operator").description("Change the operator address for a validator wallet").requiredOption("--validator <address>", "Validator wallet address").requiredOption("--operator <address>", "New operator address").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("set-operator").description("Change the operator address for a validator wallet").requiredOption("--validator <address>", "Validator wallet address").requiredOption("--operator <address>", "New operator address").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new SetOperatorAction();
     await action.execute(options);
   });
-  staking.command("set-identity").description("Set validator identity metadata (moniker, website, socials, etc.)").requiredOption("--validator <address>", "Validator wallet address").requiredOption("--moniker <name>", "Validator display name").option("--logo-uri <uri>", "Logo URI").option("--website <url>", "Website URL").option("--description <text>", "Description").option("--email <email>", "Contact email").option("--twitter <handle>", "Twitter handle").option("--telegram <handle>", "Telegram handle").option("--github <handle>", "GitHub handle").option("--extra-cid <cid>", "Extra data as IPFS CID or hex bytes (0x...)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("set-identity").description("Set validator identity metadata (moniker, website, socials, etc.)").requiredOption("--validator <address>", "Validator wallet address").requiredOption("--moniker <name>", "Validator display name").option("--logo-uri <uri>", "Logo URI").option("--website <url>", "Website URL").option("--description <text>", "Description").option("--email <email>", "Contact email").option("--twitter <handle>", "Twitter handle").option("--telegram <handle>", "Telegram handle").option("--github <handle>", "GitHub handle").option("--extra-cid <cid>", "Extra data as IPFS CID or hex bytes (0x...)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new SetIdentityAction();
     await action.execute(options);
   });
-  staking.command("delegator-join").description("Join as a delegator by staking with a validator").requiredOption("--validator <address>", "Validator address to delegate to").requiredOption("--amount <amount>", "Amount to stake (in wei or with 'eth'/'gen' suffix)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("delegator-join").description("Join as a delegator by staking with a validator").requiredOption("--validator <address>", "Validator address to delegate to").requiredOption("--amount <amount>", "Amount to stake (in wei or with 'eth'/'gen' suffix)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new DelegatorJoinAction();
     await action.execute(options);
   });
-  staking.command("delegator-exit").description("Exit as a delegator by withdrawing shares from a validator").requiredOption("--validator <address>", "Validator address to exit from").requiredOption("--shares <shares>", "Number of shares to withdraw").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("delegator-exit").description("Exit as a delegator by withdrawing shares from a validator").requiredOption("--validator <address>", "Validator address to exit from").requiredOption("--shares <shares>", "Number of shares to withdraw").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new DelegatorExitAction();
     await action.execute(options);
   });
-  staking.command("delegator-claim").description("Claim delegator withdrawals after unbonding period").requiredOption("--validator <address>", "Validator address").option("--delegator <address>", "Delegator address (defaults to signer)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("delegator-claim").description("Claim delegator withdrawals after unbonding period").requiredOption("--validator <address>", "Validator address").option("--delegator <address>", "Delegator address (defaults to signer)").option("--account <name>", "Account to use").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new DelegatorClaimAction();
     await action.execute(options);
   });
-  staking.command("validator-info").description("Get information about a validator").option("--validator <address>", "Validator address (defaults to signer)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("validator-info").description("Get information about a validator").option("--validator <address>", "Validator address (defaults to signer)").option("--account <name>", "Account to use (for default validator address)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new StakingInfoAction();
     await action.getValidatorInfo(options);
   });
-  staking.command("stake-info").description("Get stake info for a delegator with a validator").requiredOption("--validator <address>", "Validator address").option("--delegator <address>", "Delegator address (defaults to signer)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
+  staking.command("delegation-info").description("Get delegation info for a delegator with a validator").requiredOption("--validator <address>", "Validator address").option("--delegator <address>", "Delegator address (defaults to signer)").option("--account <name>", "Account to use (for default delegator address)").option("--network <network>", "Network to use (localnet, testnet-asimov)").option("--rpc <rpcUrl>", "RPC URL for the network").option("--staking-address <address>", "Staking contract address (overrides chain config)").action(async (options) => {
     const action = new StakingInfoAction();
     await action.getStakeInfo(options);
   });