genlayer 0.32.0 → 0.32.1

package/src/lib/actions/BaseAction.ts

@@ -44,16 +44,16 @@ export function resolveNetwork(stored: string | undefined): GenLayerChain {
 }
 import { ethers } from "ethers";
 import { writeFileSync, existsSync, readFileSync } from "fs";
-import { KeystoreData } from "../interfaces/KeystoreData";
 
 export class BaseAction extends ConfigFileManager {
-  private static readonly DEFAULT_KEYSTORE_PATH = "./keypair.json";
+  private static readonly DEFAULT_ACCOUNT_NAME = "default";
   private static readonly MAX_PASSWORD_ATTEMPTS = 3;
-  private static readonly MIN_PASSWORD_LENGTH = 8;
+  protected static readonly MIN_PASSWORD_LENGTH = 8;
 
   private spinner: Ora;
   private _genlayerClient: GenLayerClient<GenLayerChain> | null = null;
   protected keychainManager: KeychainManager;
+  protected accountOverride: string | null = null;
 
   constructor() {
     super();
@@ -61,28 +61,28 @@ export class BaseAction extends ConfigFileManager {
     this.keychainManager = new KeychainManager();
   }
 
-  private async decryptKeystore(keystoreData: KeystoreData, attempt: number = 1): Promise<string> {
+  private async decryptKeystore(keystoreJson: string, attempt: number = 1): Promise<string> {
     try {
-      const message = attempt === 1 
-        ? "Enter password to decrypt keystore:" 
+      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);
     }
   }
 
-  protected isValidKeystoreFormat(data: any): data is KeystoreData {
+  protected isValidKeystoreFormat(data: any): boolean {
+    // Standard web3 keystore format has 'crypto' (or 'Crypto') and 'address' fields
     return Boolean(
-      data && 
-      data.version === 1 && 
-      typeof data.encrypted === "string" && 
+      data &&
+      (data.crypto || data.Crypto) &&
       typeof data.address === "string"
     );
   }
@@ -107,52 +107,80 @@ export class BaseAction extends ConfigFileManager {
     return this._genlayerClient;
   }
 
+  protected resolveAccountName(): string {
+    // Priority: explicit override > config active account > default
+    if (this.accountOverride) {
+      return this.accountOverride;
+    }
+    const activeAccount = this.getActiveAccount();
+    if (activeAccount) {
+      return activeAccount;
+    }
+    return BaseAction.DEFAULT_ACCOUNT_NAME;
+  }
+
   private async getAccount(readOnly: boolean = false): Promise<Account | Address> {
-    let keypairPath = this.getConfigByKey("keyPairPath");
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
     let decryptedPrivateKey;
-    let keystoreData;
+    let keystoreJson: string;
+    let keystoreData: any;
 
-    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.", undefined, 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) {
+        // Verify cached key matches keystore address
+        const tempAccount = createAccount(cachedKey as Hash);
+        const cachedAddress = tempAccount.address.toLowerCase();
+        const keystoreAddress = `0x${keystoreData.address.toLowerCase().replace(/^0x/, '')}`;
+        if (cachedAddress === keystoreAddress) {
+          decryptedPrivateKey = cachedKey;
+        } else {
+          // Cached key doesn't match keystore - invalidate it
+          await this.keychainManager.removePrivateKey(accountName);
+          decryptedPrivateKey = await this.decryptKeystore(keystoreJson);
+        }
+      } else {
+        decryptedPrivateKey = await this.decryptKeystore(keystoreJson);
+      }
     }
     return createAccount(decryptedPrivateKey as Hash);
   }
 
-  private getAddress(keystoreData: KeystoreData): Address {
+  private getAddress(keystoreData: any): Address {
     return keystoreData.address as Address;
   }
 
-  protected async createKeypair(outputPath: string, overwrite: boolean): Promise<string> {
-    const finalOutputPath = this.getFilePath(outputPath);
+  protected async createKeypairByName(accountName: string, overwrite: boolean): Promise<string> {
+    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):");
     const confirmPassword = await this.promptPassword("Confirm password:");
 
@@ -164,19 +192,17 @@ export class BaseAction extends ConfigFileManager {
       this.failSpinner(`Password must be at least ${BaseAction.MIN_PASSWORD_LENGTH} characters long`);
     }
 
+    // Write standard web3 keystore format directly
     const encryptedJson = await wallet.encrypt(password);
-    
-    const keystoreData: 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);
+
+    // Set as active account if no active account exists
+    if (!this.getActiveAccount()) {
+      this.setActiveAccount(accountName);
+    }
+
+    await this.keychainManager.removePrivateKey(accountName);
+
     return wallet.privateKey;
   }
 

package/src/lib/config/ConfigFileManager.ts

@@ -2,15 +2,26 @@ import path from "path";
 import os from "os";
 import fs from "fs";
 
+export interface AccountInfo {
+  name: string;
+  address: string;
+  path: string;
+}
+
 export class ConfigFileManager {
   private folderPath: string;
   private configFilePath: string;
+  private keystoresPath: string;
 
   constructor(baseFolder: string = ".genlayer/", configFileName: string = "genlayer-config.json") {
     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();
   }
 
   private ensureFolderExists(): void {
@@ -19,12 +30,76 @@ export class ConfigFileManager {
     }
   }
 
+  private ensureKeystoresDirExists(): void {
+    if (!fs.existsSync(this.keystoresPath)) {
+      fs.mkdirSync(this.keystoresPath, { recursive: true });
+    }
+  }
+
   private ensureConfigFileExists(): void {
     if (!fs.existsSync(this.configFilePath)) {
       fs.writeFileSync(this.configFilePath, JSON.stringify({}, null, 2));
     }
   }
 
+  private migrateOldConfig(): void {
+    const config = this.getConfig();
+    if (config.keyPairPath && !config.activeAccount) {
+      const oldPath = config.keyPairPath;
+      if (fs.existsSync(oldPath)) {
+        const newPath = this.getKeystorePath("default");
+        // Read old keystore and convert format if needed
+        const content = fs.readFileSync(oldPath, "utf-8");
+        const web3Content = this.convertToWeb3Format(content);
+        fs.writeFileSync(newPath, web3Content);
+        delete config.keyPairPath;
+        config.activeAccount = "default";
+        fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
+      }
+    }
+  }
+
+  private migrateKeystoreFormats(): void {
+    if (!fs.existsSync(this.keystoresPath)) {
+      return;
+    }
+    const files = fs.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 = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        // Check if it's old GenLayer format (has 'encrypted' string field)
+        if (parsed.encrypted && typeof parsed.encrypted === "string") {
+          const web3Content = this.convertToWeb3Format(content);
+          fs.writeFileSync(filePath, web3Content);
+        }
+        // If it has 'crypto' field, it's already web3 format - skip
+      } catch {
+        // Skip files that can't be parsed
+      }
+    }
+  }
+
+  private convertToWeb3Format(content: string): string {
+    try {
+      const parsed = JSON.parse(content);
+      // If it's GenLayer wrapper format (has 'encrypted' string field)
+      if (parsed.encrypted && typeof parsed.encrypted === "string") {
+        // The 'encrypted' field contains the actual web3 keystore JSON
+        return parsed.encrypted;
+      }
+      // Already web3 format or unknown - return as-is
+      return content;
+    } catch {
+      return content;
+    }
+  }
+
   getFolderPath(): string {
     return this.folderPath;
   }
@@ -48,4 +123,72 @@ export class ConfigFileManager {
     config[key] = value;
     fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
   }
+
+  removeConfig(key: string): void {
+    const config = this.getConfig();
+    delete config[key];
+    fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
+  }
+
+  getKeystoresPath(): string {
+    return this.keystoresPath;
+  }
+
+  getKeystorePath(name: string): string {
+    return path.resolve(this.keystoresPath, `${name}.json`);
+  }
+
+  accountExists(name: string): boolean {
+    return fs.existsSync(this.getKeystorePath(name));
+  }
+
+  getActiveAccount(): string | null {
+    return this.getConfigByKey("activeAccount");
+  }
+
+  setActiveAccount(name: string): void {
+    if (!this.accountExists(name)) {
+      throw new Error(`Account '${name}' does not exist`);
+    }
+    this.writeConfig("activeAccount", name);
+  }
+
+  listAccounts(): AccountInfo[] {
+    if (!fs.existsSync(this.keystoresPath)) {
+      return [];
+    }
+    const files = fs.readdirSync(this.keystoresPath);
+    const accounts: AccountInfo[] = [];
+
+    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(fs.readFileSync(filePath, "utf-8"));
+        const addr = content.address || "unknown";
+        accounts.push({
+          name,
+          address: addr.startsWith("0x") ? addr : `0x${addr}`,
+          path: filePath,
+        });
+      } catch {
+        // Skip invalid files
+      }
+    }
+    return accounts;
+  }
+
+  removeAccount(name: string): void {
+    const keystorePath = this.getKeystorePath(name);
+    if (!fs.existsSync(keystorePath)) {
+      throw new Error(`Account '${name}' does not exist`);
+    }
+    fs.unlinkSync(keystorePath);
+
+    // If this was the active account, clear it
+    if (this.getActiveAccount() === name) {
+      this.removeConfig("activeAccount");
+    }
+  }
 }

package/src/lib/config/KeychainManager.ts

@@ -2,10 +2,13 @@ import {default as keytar} from 'keytar';
 
 export class KeychainManager {
   private static readonly SERVICE = 'genlayer-cli';
-  private static readonly ACCOUNT = 'default-user';
 
   constructor() {}
 
+  private getKeychainAccount(accountName: string): string {
+    return `account:${accountName}`;
+  }
+
   async isKeychainAvailable(): Promise<boolean> {
     try {
       await keytar.findCredentials('test-service');
@@ -15,15 +18,28 @@ export class KeychainManager {
     }
   }
 
-  async storePrivateKey(privateKey: string): Promise<void> {
-      return await keytar.setPassword(KeychainManager.SERVICE, KeychainManager.ACCOUNT, privateKey);
+  async storePrivateKey(accountName: string, privateKey: string): Promise<void> {
+    return await keytar.setPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName), privateKey);
+  }
+
+  async getPrivateKey(accountName: string): Promise<string | null> {
+    return await keytar.getPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+  }
+
+  async removePrivateKey(accountName: string): Promise<boolean> {
+    return await keytar.deletePassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
   }
 
-  async getPrivateKey(): Promise<string | null> {
-    return await keytar.getPassword(KeychainManager.SERVICE, KeychainManager.ACCOUNT);
+  async listUnlockedAccounts(): Promise<string[]> {
+    const credentials = await keytar.findCredentials(KeychainManager.SERVICE);
+    return credentials
+      .map(c => c.account)
+      .filter(a => a.startsWith('account:'))
+      .map(a => a.replace('account:', ''));
   }
 
-  async removePrivateKey(): Promise<boolean> {
-    return await keytar.deletePassword(KeychainManager.SERVICE, KeychainManager.ACCOUNT);
+  async isAccountUnlocked(accountName: string): Promise<boolean> {
+    const key = await this.getPrivateKey(accountName);
+    return key !== null;
   }
 } 

package/tests/actions/create.test.ts

@@ -1,18 +1,31 @@
 import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
 import {CreateAccountAction} from "../../src/commands/account/create";
+import {readFileSync, existsSync} from "fs";
+import os from "os";
+
+vi.mock("fs");
+vi.mock("os");
 
 describe("CreateAccountAction", () => {
   let createAction: CreateAccountAction;
+  const mockKeystorePath = "/mocked/home/.genlayer/keystores/main.json";
 
   beforeEach(() => {
     vi.clearAllMocks();
+    // Setup mocks before creating the action (needed for constructor)
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({activeAccount: "default"}));
+
     createAction = new CreateAccountAction();
 
     // Mock the BaseAction methods
     vi.spyOn(createAction as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(createAction as any, "succeedSpinner").mockImplementation(() => {});
     vi.spyOn(createAction as any, "failSpinner").mockImplementation(() => {});
-    vi.spyOn(createAction as any, "createKeypair").mockResolvedValue("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef");
+    vi.spyOn(createAction as any, "createKeypairByName").mockResolvedValue("0x1234567890abcdef");
+    vi.spyOn(createAction as any, "setActiveAccount").mockImplementation(() => {});
+    vi.spyOn(createAction as any, "getKeystorePath").mockReturnValue(mockKeystorePath);
   });
 
   afterEach(() => {
@@ -20,26 +33,33 @@ describe("CreateAccountAction", () => {
   });
 
   test("successfully creates and saves an encrypted keystore", async () => {
-    const options = {output: "keypair.json", overwrite: false};
+    const options = {name: "main", overwrite: false, setActive: true};
 
     await createAction.execute(options);
 
-    expect(createAction["startSpinner"]).toHaveBeenCalledWith("Creating encrypted keystore...");
-    expect(createAction["createKeypair"]).toHaveBeenCalledWith(
-      options.output,
-      options.overwrite
-    );
+    expect(createAction["startSpinner"]).toHaveBeenCalledWith("Creating account 'main'...");
+    expect(createAction["createKeypairByName"]).toHaveBeenCalledWith("main", false);
+    expect(createAction["setActiveAccount"]).toHaveBeenCalledWith("main");
     expect(createAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "Account created and saved to: keypair.json",
+      `Account 'main' created at: ${mockKeystorePath}`,
     );
   });
 
   test("handles errors during keystore creation", async () => {
     const mockError = new Error("Mocked creation error");
-    vi.spyOn(createAction as any, "createKeypair").mockRejectedValue(mockError);
+    vi.spyOn(createAction as any, "createKeypairByName").mockRejectedValue(mockError);
 
-    await createAction.execute({output: "keypair.json", overwrite: true});
+    await createAction.execute({name: "main", overwrite: true});
 
     expect(createAction["failSpinner"]).toHaveBeenCalledWith("Failed to create account", mockError);
   });
+
+  test("skips setting active account when setActive is false", async () => {
+    const options = {name: "validator", overwrite: false, setActive: false};
+
+    await createAction.execute(options);
+
+    expect(createAction["setActiveAccount"]).not.toHaveBeenCalled();
+    expect(createAction["succeedSpinner"]).toHaveBeenCalled();
+  });
 });

package/tests/actions/deploy.test.ts

@@ -1,11 +1,13 @@
 import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
 import fs from "fs";
+import os from "os";
 import {createClient, createAccount} from "genlayer-js";
 import {DeployAction, DeployOptions} from "../../src/commands/contracts/deploy";
 import {buildSync} from "esbuild";
 import {pathToFileURL} from "url";
 
 vi.mock("fs");
+vi.mock("os");
 vi.mock("genlayer-js");
 vi.mock("esbuild", () => ({
   buildSync: vi.fn(),
@@ -23,6 +25,11 @@ describe("DeployAction", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
+    // Setup mocks before creating the action (needed for constructor)
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({activeAccount: "default"}));
+
     vi.mocked(createClient).mockReturnValue(mockClient as any);
     vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
     deployer = new DeployAction();

package/tests/actions/lock.test.ts

@@ -1,19 +1,30 @@
 import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
 import {LockAccountAction} from "../../src/commands/account/lock";
+import {readFileSync, existsSync} from "fs";
+import os from "os";
+
+vi.mock("fs");
+vi.mock("os");
 
 describe("LockAccountAction", () => {
   let lockAction: LockAccountAction;
 
   beforeEach(() => {
     vi.clearAllMocks();
+    // Setup mocks before creating the action (needed for constructor)
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(existsSync).mockReturnValue(true);
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({activeAccount: "default"}));
+
     lockAction = new LockAccountAction();
-    
+
     // Mock the BaseAction methods
     vi.spyOn(lockAction as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(lockAction as any, "setSpinnerText").mockImplementation(() => {});
     vi.spyOn(lockAction as any, "succeedSpinner").mockImplementation(() => {});
     vi.spyOn(lockAction as any, "failSpinner").mockImplementation(() => {});
-    
+    vi.spyOn(lockAction as any, "resolveAccountName").mockReturnValue("default");
+
     // Mock keychainManager
     vi.spyOn(lockAction["keychainManager"], "isKeychainAvailable").mockResolvedValue(true);
     vi.spyOn(lockAction["keychainManager"], "getPrivateKey").mockResolvedValue("test-private-key");
@@ -29,11 +40,11 @@ describe("LockAccountAction", () => {
 
     expect(lockAction["startSpinner"]).toHaveBeenCalledWith("Checking keychain availability...");
     expect(lockAction["keychainManager"].isKeychainAvailable).toHaveBeenCalled();
-    expect(lockAction["setSpinnerText"]).toHaveBeenCalledWith("Checking for cached private key...");
-    expect(lockAction["keychainManager"].getPrivateKey).toHaveBeenCalled();
-    expect(lockAction["setSpinnerText"]).toHaveBeenCalledWith("Removing private key from OS keychain...");
-    expect(lockAction["keychainManager"].removePrivateKey).toHaveBeenCalled();
-    expect(lockAction["succeedSpinner"]).toHaveBeenCalledWith("Account locked! Private key removed from OS keychain.");
+    expect(lockAction["setSpinnerText"]).toHaveBeenCalledWith("Checking for cached private key for 'default'...");
+    expect(lockAction["keychainManager"].getPrivateKey).toHaveBeenCalledWith("default");
+    expect(lockAction["setSpinnerText"]).toHaveBeenCalledWith("Removing private key for 'default' from OS keychain...");
+    expect(lockAction["keychainManager"].removePrivateKey).toHaveBeenCalledWith("default");
+    expect(lockAction["succeedSpinner"]).toHaveBeenCalledWith("Account 'default' locked! Private key removed from OS keychain.");
   });
 
   test("fails when keychain is not available", async () => {
@@ -51,7 +62,7 @@ describe("LockAccountAction", () => {
 
     await lockAction.execute();
 
-    expect(lockAction["succeedSpinner"]).toHaveBeenCalledWith("Account is already locked.");
+    expect(lockAction["succeedSpinner"]).toHaveBeenCalledWith("Account 'default' is already locked.");
     expect(lockAction["keychainManager"].removePrivateKey).not.toHaveBeenCalled();
   });
 
@@ -63,4 +74,13 @@ describe("LockAccountAction", () => {
 
     expect(lockAction["failSpinner"]).toHaveBeenCalledWith("Failed to lock account.", mockError);
   });
+
+  test("uses account option when provided", async () => {
+    vi.spyOn(lockAction as any, "resolveAccountName").mockReturnValue("validator");
+
+    await lockAction.execute({account: "validator"});
+
+    expect(lockAction["accountOverride"]).toBe("validator");
+    expect(lockAction["setSpinnerText"]).toHaveBeenCalledWith("Checking for cached private key for 'validator'...");
+  });
 });