genlayer 0.30.0 → 0.32.0

package/src/commands/staking/validatorDeposit.ts

@@ -0,0 +1,35 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+
+export interface ValidatorDepositOptions extends StakingConfig {
+  amount: string;
+}
+
+export class ValidatorDepositAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorDepositOptions): Promise<void> {
+    this.startSpinner("Making validator deposit...");
+
+    try {
+      const client = await this.getStakingClient(options);
+      const amount = this.parseAmount(options.amount);
+
+      this.setSpinnerText(`Depositing ${this.formatAmount(amount)} to validator stake...`);
+
+      const result = await client.validatorDeposit({amount});
+
+      const output = {
+        transactionHash: result.transactionHash,
+        amount: this.formatAmount(amount),
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Deposit successful!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to make deposit", error.message || error);
+    }
+  }
+}

package/src/commands/staking/validatorExit.ts

@@ -0,0 +1,44 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+
+export interface ValidatorExitOptions extends StakingConfig {
+  shares: string;
+}
+
+export class ValidatorExitAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorExitOptions): Promise<void> {
+    this.startSpinner("Initiating validator exit...");
+
+    try {
+      let shares: bigint;
+      try {
+        shares = BigInt(options.shares);
+        if (shares <= 0n) throw new Error("must be positive");
+      } catch {
+        this.failSpinner(`Invalid shares value: "${options.shares}". Must be a positive whole number.`);
+        return;
+      }
+
+      const client = await this.getStakingClient(options);
+
+      this.setSpinnerText(`Exiting with ${shares} shares...`);
+
+      const result = await client.validatorExit({shares});
+
+      const output = {
+        transactionHash: result.transactionHash,
+        sharesWithdrawn: shares.toString(),
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+        note: "Withdrawal will be claimable after the unbonding period",
+      };
+
+      this.succeedSpinner("Exit initiated successfully!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to exit", error.message || error);
+    }
+  }
+}

package/src/commands/staking/validatorJoin.ts

@@ -0,0 +1,47 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+export interface ValidatorJoinOptions extends StakingConfig {
+  amount: string;
+  operator?: string;
+}
+
+export class ValidatorJoinAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorJoinOptions): Promise<void> {
+    this.startSpinner("Creating a new validator...");
+
+    try {
+      const client = await this.getStakingClient(options);
+      const amount = this.parseAmount(options.amount);
+      const signerAddress = await this.getSignerAddress();
+
+      this.setSpinnerText(`Creating validator with ${this.formatAmount(amount)} stake...`);
+      this.log(`  From: ${signerAddress}`);
+      if (options.operator) {
+        this.log(`  Operator: ${options.operator}`);
+      }
+
+      const result = await client.validatorJoin({
+        amount,
+        operator: options.operator as Address | undefined,
+      });
+
+      const output = {
+        transactionHash: result.transactionHash,
+        validatorWallet: result.validatorWallet,
+        amount: result.amount,
+        operator: result.operator,
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Validator created successfully!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to create validator", error.message || error);
+    }
+  }
+}

package/src/commands/staking/validatorPrime.ts

@@ -0,0 +1,35 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+export interface ValidatorPrimeOptions extends StakingConfig {
+  validator: string;
+}
+
+export class ValidatorPrimeAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorPrimeOptions): Promise<void> {
+    this.startSpinner("Priming validator...");
+
+    try {
+      const client = await this.getStakingClient(options);
+
+      this.setSpinnerText(`Priming validator ${options.validator}...`);
+
+      const result = await client.validatorPrime({validator: options.validator as Address});
+
+      const output = {
+        transactionHash: result.transactionHash,
+        validator: options.validator,
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Validator primed for next epoch!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to prime validator", error.message || error);
+    }
+  }
+}

package/src/index.ts

@@ -3,7 +3,7 @@ import {program} from "commander";
 import {version} from "../package.json";
 import {CLI_DESCRIPTION} from "../src/lib/config/text";
 import {initializeGeneralCommands} from "../src/commands/general";
-import {initializeKeygenCommands} from "../src/commands/keygen";
+import {initializeAccountCommands} from "../src/commands/account";
 import {initializeContractsCommands} from "../src/commands/contracts";
 import {initializeConfigCommands} from "../src/commands/config";
 import {initializeValidatorCommands} from "../src/commands/localnet";
@@ -11,11 +11,12 @@ import {initializeUpdateCommands} from "../src/commands/update";
 import {initializeScaffoldCommands} from "../src/commands/scaffold";
 import {initializeNetworkCommands} from "../src/commands/network";
 import {initializeTransactionsCommands} from "../src/commands/transactions";
+import {initializeStakingCommands} from "../src/commands/staking";
 
 export function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
   initializeGeneralCommands(program);
-  initializeKeygenCommands(program);
+  initializeAccountCommands(program);
   initializeContractsCommands(program);
   initializeConfigCommands(program);
   initializeUpdateCommands(program);
@@ -23,6 +24,7 @@ export function initializeCLI() {
   initializeScaffoldCommands(program);
   initializeNetworkCommands(program);
   initializeTransactionsCommands(program);
+  initializeStakingCommands(program);
   program.parse(process.argv);
 }
 

package/src/lib/actions/BaseAction.ts

@@ -5,8 +5,43 @@ import chalk from "chalk";
 import inquirer from "inquirer";
 import { inspect } from "util";
 import {createClient, createAccount} from "genlayer-js";
-import {localnet} from "genlayer-js/chains";
+import {localnet, studionet, testnetAsimov} from "genlayer-js/chains";
 import type {GenLayerClient, GenLayerChain, Hash, Address, Account} from "genlayer-js/types";
+
+// Built-in networks - always resolve fresh from genlayer-js
+export const BUILT_IN_NETWORKS: Record<string, GenLayerChain> = {
+  "localnet": localnet,
+  "studionet": studionet,
+  "testnet-asimov": testnetAsimov,
+};
+
+/**
+ * Resolves a stored network config to a fresh chain object.
+ * Handles both new format (alias string) and old format (JSON object) for backwards compat.
+ */
+export function resolveNetwork(stored: string | undefined): GenLayerChain {
+  if (!stored) return localnet;
+
+  // Try as alias first (new format)
+  if (BUILT_IN_NETWORKS[stored]) {
+    return BUILT_IN_NETWORKS[stored];
+  }
+
+  // Backwards compat: try parsing as JSON (old format)
+  try {
+    const parsed = JSON.parse(stored);
+    // If it has a known name, use fresh version instead
+    const alias = Object.entries(BUILT_IN_NETWORKS)
+      .find(([_, chain]) => chain.name === parsed.name)?.[0];
+    if (alias) {
+      return BUILT_IN_NETWORKS[alias];
+    }
+    // Custom network - use as-is
+    return parsed;
+  } catch {
+    throw new Error(`Unknown network: ${stored}`);
+  }
+}
 import { ethers } from "ethers";
 import { writeFileSync, existsSync, readFileSync } from "fs";
 import { KeystoreData } from "../interfaces/KeystoreData";
@@ -38,7 +73,6 @@ export class BaseAction extends ConfigFileManager {
     } catch (error) {
       if (attempt >= BaseAction.MAX_PASSWORD_ATTEMPTS) {
         this.failSpinner(`Maximum password attempts exceeded (${BaseAction.MAX_PASSWORD_ATTEMPTS}/${BaseAction.MAX_PASSWORD_ATTEMPTS}).`);
-        process.exit(1);
       }
       return await this.decryptKeystore(keystoreData, attempt + 1);
     }
@@ -62,8 +96,7 @@ export class BaseAction extends ConfigFileManager {
 
   protected async getClient(rpcUrl?: string, readOnly: boolean = false): Promise<GenLayerClient<GenLayerChain>> {
     if (!this._genlayerClient) {
-      const networkConfig = this.getConfig().network;
-      const network = networkConfig ? JSON.parse(networkConfig) : localnet;
+      const network = resolveNetwork(this.getConfig().network);
       const account = await this.getAccount(readOnly);
       this._genlayerClient = createClient({
         chain: network,
@@ -88,7 +121,7 @@ export class BaseAction extends ConfigFileManager {
     keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
 
     if (!this.isValidKeystoreFormat(keystoreData)) {
-      this.failSpinner("Invalid keystore format. Expected encrypted keystore file.");
+      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")!;
@@ -116,7 +149,6 @@ export class BaseAction extends ConfigFileManager {
 
     if (existsSync(finalOutputPath) && !overwrite) {
       this.failSpinner(`The file at ${finalOutputPath} already exists. Use the '--overwrite' option to replace it.`);
-      process.exit(1);
     }
 
     const wallet = ethers.Wallet.createRandom();
@@ -126,12 +158,10 @@ export class BaseAction extends ConfigFileManager {
 
     if (password !== confirmPassword) {
       this.failSpinner("Passwords do not match");
-      process.exit(1);
     }
 
     if (password.length < BaseAction.MIN_PASSWORD_LENGTH) {
       this.failSpinner(`Password must be at least ${BaseAction.MIN_PASSWORD_LENGTH} characters long`);
-      process.exit(1);
     }
 
     const encryptedJson = await wallet.encrypt(password);
@@ -220,10 +250,13 @@ export class BaseAction extends ConfigFileManager {
     this.spinner.succeed(chalk.green(message));
   }
 
-  protected failSpinner(message: string, error?:any): void {
+  protected failSpinner(message: string, error?: any, shouldExit = true): void {
     if (error) this.log("Error:", error);
-    console.log('');
+    console.log("");
     this.spinner.fail(chalk.red(message));
+    if (shouldExit) {
+      process.exit(1);
+    }
   }
 
   protected stopSpinner(): void {

package/tests/actions/code.test.ts

@@ -0,0 +1,87 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import {CodeAction} from "../../src/commands/contracts/code";
+
+vi.mock("genlayer-js");
+
+describe("CodeAction", () => {
+  let codeAction: CodeAction;
+  const mockClient = {
+    getContractCode: vi.fn(),
+    initializeConsensusSmartContract: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
+    codeAction = new CodeAction();
+    vi.spyOn(codeAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(codeAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(codeAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(codeAction as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(codeAction as any, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("gets contract code successfully", async () => {
+    const mockResult = "0x600160...";
+
+    vi.mocked(mockClient.getContractCode).mockResolvedValue(mockResult as any);
+
+    await codeAction.code({
+      contractAddress: "0xMockedContract",
+    });
+
+    expect(mockClient.getContractCode).toHaveBeenCalledWith("0xMockedContract");
+    expect(codeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Contract code retrieved successfully",
+      mockResult,
+    );
+  });
+
+  test("handles getContractCode errors", async () => {
+    vi.mocked(mockClient.getContractCode).mockRejectedValue(new Error("Mocked code error"));
+
+    await codeAction.code({contractAddress: "0xMockedContract"});
+
+    expect(codeAction["failSpinner"]).toHaveBeenCalledWith("Error retrieving contract code", expect.any(Error));
+  });
+
+  test("uses custom RPC URL when provided", async () => {
+    const mockResult = "0x600160...";
+    vi.mocked(mockClient.getContractCode).mockResolvedValue(mockResult as any);
+
+    await codeAction.code({
+      contractAddress: "0xMockedContract",
+      rpc: "https://custom-rpc-url.com",
+    });
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: "https://custom-rpc-url.com",
+      }),
+    );
+    expect(mockClient.getContractCode).toHaveBeenCalledWith("0xMockedContract");
+    expect(codeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Contract code retrieved successfully",
+      mockResult,
+    );
+  });
+
+  test("initializes consensus smart contract", async () => {
+    vi.mocked(mockClient.getContractCode).mockResolvedValue("0x" as any);
+
+    await codeAction.code({contractAddress: "0xMockedContract"});
+
+    expect(mockClient.initializeConsensusSmartContract).toHaveBeenCalled();
+  });
+});
+
+

package/tests/actions/create.test.ts

@@ -1,18 +1,18 @@
 import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
-import {KeypairCreator} from "../../src/commands/keygen/create";
+import {CreateAccountAction} from "../../src/commands/account/create";
 
-describe("KeypairCreator", () => {
-  let keypairCreator: KeypairCreator;
+describe("CreateAccountAction", () => {
+  let createAction: CreateAccountAction;
 
   beforeEach(() => {
     vi.clearAllMocks();
-    keypairCreator = new KeypairCreator();
-    
+    createAction = new CreateAccountAction();
+
     // Mock the BaseAction methods
-    vi.spyOn(keypairCreator as any, "startSpinner").mockImplementation(() => {});
-    vi.spyOn(keypairCreator as any, "succeedSpinner").mockImplementation(() => {});
-    vi.spyOn(keypairCreator as any, "failSpinner").mockImplementation(() => {});
-    vi.spyOn(keypairCreator as any, "createKeypair").mockResolvedValue("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef");
+    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");
   });
 
   afterEach(() => {
@@ -22,24 +22,24 @@ describe("KeypairCreator", () => {
   test("successfully creates and saves an encrypted keystore", async () => {
     const options = {output: "keypair.json", overwrite: false};
 
-    await keypairCreator.createKeypairAction(options);
+    await createAction.execute(options);
 
-    expect(keypairCreator["startSpinner"]).toHaveBeenCalledWith("Creating encrypted keystore...");
-    expect(keypairCreator["createKeypair"]).toHaveBeenCalledWith(
-      options.output, 
+    expect(createAction["startSpinner"]).toHaveBeenCalledWith("Creating encrypted keystore...");
+    expect(createAction["createKeypair"]).toHaveBeenCalledWith(
+      options.output,
       options.overwrite
     );
-    expect(keypairCreator["succeedSpinner"]).toHaveBeenCalledWith(
-      "Encrypted keystore successfully created and saved to: keypair.json",
+    expect(createAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Account created and saved to: keypair.json",
     );
   });
 
   test("handles errors during keystore creation", async () => {
     const mockError = new Error("Mocked creation error");
-    vi.spyOn(keypairCreator as any, "createKeypair").mockRejectedValue(mockError);
+    vi.spyOn(createAction as any, "createKeypair").mockRejectedValue(mockError);
 
-    await keypairCreator.createKeypairAction({output: "keypair.json", overwrite: true});
+    await createAction.execute({output: "keypair.json", overwrite: true});
 
-    expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith("Failed to generate keystore", mockError);
+    expect(createAction["failSpinner"]).toHaveBeenCalledWith("Failed to create account", mockError);
   });
 });

package/tests/actions/lock.test.ts

@@ -1,12 +1,12 @@
 import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
-import {LockAction} from "../../src/commands/keygen/lock";
+import {LockAccountAction} from "../../src/commands/account/lock";
 
-describe("LockAction", () => {
-  let lockAction: LockAction;
+describe("LockAccountAction", () => {
+  let lockAction: LockAccountAction;
 
   beforeEach(() => {
     vi.clearAllMocks();
-    lockAction = new LockAction();
+    lockAction = new LockAccountAction();
     
     // Mock the BaseAction methods
     vi.spyOn(lockAction as any, "startSpinner").mockImplementation(() => {});
@@ -33,7 +33,7 @@ describe("LockAction", () => {
     expect(lockAction["keychainManager"].getPrivateKey).toHaveBeenCalled();
     expect(lockAction["setSpinnerText"]).toHaveBeenCalledWith("Removing private key from OS keychain...");
     expect(lockAction["keychainManager"].removePrivateKey).toHaveBeenCalled();
-    expect(lockAction["succeedSpinner"]).toHaveBeenCalledWith("Wallet locked successfully! Your private key has been removed from the OS keychain.");
+    expect(lockAction["succeedSpinner"]).toHaveBeenCalledWith("Account locked! Private key removed from OS keychain.");
   });
 
   test("fails when keychain is not available", async () => {
@@ -51,7 +51,7 @@ describe("LockAction", () => {
 
     await lockAction.execute();
 
-    expect(lockAction["succeedSpinner"]).toHaveBeenCalledWith("Wallet is already locked (no cached key found in OS keychain).");
+    expect(lockAction["succeedSpinner"]).toHaveBeenCalledWith("Account is already locked.");
     expect(lockAction["keychainManager"].removePrivateKey).not.toHaveBeenCalled();
   });
 
@@ -61,6 +61,6 @@ describe("LockAction", () => {
 
     await lockAction.execute();
 
-    expect(lockAction["failSpinner"]).toHaveBeenCalledWith("Failed to lock wallet.", mockError);
+    expect(lockAction["failSpinner"]).toHaveBeenCalledWith("Failed to lock account.", mockError);
   });
 }); 

package/tests/actions/setNetwork.test.ts

@@ -26,7 +26,7 @@ describe("NetworkActions", () => {
   test("setNetwork method sets network by valid name", async () => {
     await networkActions.setNetwork(localnet.name);
 
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(localnet));
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "localnet");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
       `Network successfully set to ${localnet.name}`,
     );
@@ -35,7 +35,7 @@ describe("NetworkActions", () => {
   test("setNetwork method sets network by valid alias", async () => {
     await networkActions.setNetwork("localnet");
 
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(localnet));
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "localnet");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
       `Network successfully set to ${localnet.name}`,
     );
@@ -44,7 +44,7 @@ describe("NetworkActions", () => {
   test("setNetwork method sets studionet by name", async () => {
     await networkActions.setNetwork(studionet.name);
 
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(studionet));
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "studionet");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
       `Network successfully set to ${studionet.name}`,
     );
@@ -53,7 +53,7 @@ describe("NetworkActions", () => {
   test("setNetwork method sets studionet by alias", async () => {
     await networkActions.setNetwork("studionet");
 
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(studionet));
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "studionet");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
       `Network successfully set to ${studionet.name}`,
     );
@@ -62,7 +62,7 @@ describe("NetworkActions", () => {
   test("setNetwork method sets testnet-asimov by name", async () => {
     await networkActions.setNetwork(testnetAsimov.name);
 
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(testnetAsimov));
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "testnet-asimov");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
       `Network successfully set to ${testnetAsimov.name}`,
     );
@@ -71,7 +71,7 @@ describe("NetworkActions", () => {
   test("setNetwork method sets testnet-asimov by alias", async () => {
     await networkActions.setNetwork("testnet-asimov");
 
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(testnetAsimov));
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "testnet-asimov");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
       `Network successfully set to ${testnetAsimov.name}`,
     );
@@ -94,14 +94,8 @@ describe("NetworkActions", () => {
   });
 
   test("setNetwork method prompts user when no network name provided", async () => {
-    const mockSelectedNetwork = {
-      name: localnet.name,
-      alias: "localnet",
-      value: localnet,
-    };
-
     vi.mocked(inquirer.prompt).mockResolvedValue({
-      selectedNetwork: mockSelectedNetwork,
+      selectedNetwork: "localnet",
     });
 
     await networkActions.setNetwork();
@@ -112,74 +106,41 @@ describe("NetworkActions", () => {
         name: "selectedNetwork",
         message: "Select which network do you want to use:",
         choices: [
-          {
-            name: localnet.name,
-            alias: "localnet",
-            value: localnet,
-          },
-          {
-            name: studionet.name,
-            alias: "studionet",
-            value: studionet,
-          },
-          {
-            name: testnetAsimov.name,
-            alias: "testnet-asimov",
-            value: testnetAsimov,
-          },
+          {name: localnet.name, value: "localnet"},
+          {name: studionet.name, value: "studionet"},
+          {name: testnetAsimov.name, value: "testnet-asimov"},
         ],
       },
     ]);
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith(
-      "network",
-      JSON.stringify(mockSelectedNetwork),
-    );
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "localnet");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${mockSelectedNetwork.name}`,
+      `Network successfully set to ${localnet.name}`,
     );
   });
 
   test("setNetwork method handles interactive selection of studionet", async () => {
-    const mockSelectedNetwork = {
-      name: studionet.name,
-      alias: "studionet",
-      value: studionet,
-    };
-
     vi.mocked(inquirer.prompt).mockResolvedValue({
-      selectedNetwork: mockSelectedNetwork,
+      selectedNetwork: "studionet",
     });
 
     await networkActions.setNetwork();
 
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith(
-      "network",
-      JSON.stringify(mockSelectedNetwork),
-    );
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "studionet");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${mockSelectedNetwork.name}`,
+      `Network successfully set to ${studionet.name}`,
     );
   });
 
   test("setNetwork method handles interactive selection of testnet-asimov", async () => {
-    const mockSelectedNetwork = {
-      name: testnetAsimov.name,
-      alias: "testnet-asimov",
-      value: testnetAsimov,
-    };
-
     vi.mocked(inquirer.prompt).mockResolvedValue({
-      selectedNetwork: mockSelectedNetwork,
+      selectedNetwork: "testnet-asimov",
     });
 
     await networkActions.setNetwork();
 
-    expect(networkActions["writeConfig"]).toHaveBeenCalledWith(
-      "network",
-      JSON.stringify(mockSelectedNetwork),
-    );
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", "testnet-asimov");
     expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
-      `Network successfully set to ${mockSelectedNetwork.name}`,
+      `Network successfully set to ${testnetAsimov.name}`,
     );
   });