genlayer 0.23.0 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.25.0 (2025-07-23)
+
+### Features
+
+* Add Temporary Key Caching System with Read-Only Client Support ([#241](https://github.com/yeagerai/genlayer-cli/issues/241)) ([89d57f9](https://github.com/yeagerai/genlayer-cli/commit/89d57f9e35a331ef22edcdbd17384807c6fa18ac))
+
+## 0.24.0 (2025-07-16)
+
+### Features
+
+* Add Docker Volume Cleanup to Init Flow ([#240](https://github.com/yeagerai/genlayer-cli/issues/240)) ([e61b82c](https://github.com/yeagerai/genlayer-cli/commit/e61b82c3d31aa71860eccad510141cd3f932e4aa))
+
 ## 0.23.0 (2025-07-15)
 
 ### Features

package/dist/index.js

@@ -17856,7 +17856,7 @@ var require_semver2 = __commonJS({
 import { program } from "commander";
 
 // package.json
-var version = "0.23.0";
+var version = "0.25.0";
 var package_default = {
   name: "genlayer",
   version,
@@ -19372,14 +19372,18 @@ var rpcClient = new JsonRpcClient(DEFAULT_JSON_RPC_URL);
 import path from "path";
 import os from "os";
 import fs2 from "fs";
-var ConfigFileManager = class {
+var _ConfigFileManager = class _ConfigFileManager {
+  // 5 minutes
   constructor(baseFolder = ".genlayer/", configFileName = "genlayer-config.json") {
     __publicField(this, "folderPath");
     __publicField(this, "configFilePath");
+    __publicField(this, "tempFolderPath");
     this.folderPath = path.resolve(os.homedir(), baseFolder);
     this.configFilePath = path.resolve(this.folderPath, configFileName);
+    this.tempFolderPath = path.resolve(os.tmpdir(), "genlayer-temp");
     this.ensureFolderExists();
     this.ensureConfigFileExists();
+    this.ensureTempFolderExists();
   }
   ensureFolderExists() {
     if (!fs2.existsSync(this.folderPath)) {
@@ -19391,6 +19395,11 @@ var ConfigFileManager = class {
       fs2.writeFileSync(this.configFilePath, JSON.stringify({}, null, 2));
     }
   }
+  ensureTempFolderExists() {
+    if (!fs2.existsSync(this.tempFolderPath)) {
+      fs2.mkdirSync(this.tempFolderPath, { recursive: true, mode: 448 });
+    }
+  }
   getFolderPath() {
     return this.folderPath;
   }
@@ -19410,7 +19419,59 @@ var ConfigFileManager = class {
     config[key] = value;
     fs2.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
   }
+  storeTempFile(fileName, content) {
+    this.ensureTempFolderExists();
+    const filePath = path.resolve(this.tempFolderPath, fileName);
+    const tempData = {
+      content,
+      timestamp: Date.now()
+    };
+    fs2.writeFileSync(filePath, JSON.stringify(tempData), { mode: 384 });
+  }
+  getTempFile(fileName) {
+    const filePath = path.resolve(this.tempFolderPath, fileName);
+    if (!fs2.existsSync(filePath)) {
+      return null;
+    }
+    const fileContent = fs2.readFileSync(filePath, "utf-8");
+    const tempData = JSON.parse(fileContent);
+    if (Date.now() - tempData.timestamp > _ConfigFileManager.TEMP_FILE_EXPIRATION_MS) {
+      this.clearTempFile(fileName);
+      return null;
+    }
+    return tempData.content;
+  }
+  hasTempFile(fileName) {
+    return this.getTempFile(fileName) !== null;
+  }
+  clearTempFile(fileName) {
+    const filePath = path.resolve(this.tempFolderPath, fileName);
+    if (fs2.existsSync(filePath)) {
+      fs2.unlinkSync(filePath);
+    }
+  }
+  cleanupExpiredTempFiles() {
+    if (!fs2.existsSync(this.tempFolderPath)) {
+      return;
+    }
+    const files = fs2.readdirSync(this.tempFolderPath);
+    const now = Date.now();
+    for (const file of files) {
+      const filePath = path.resolve(this.tempFolderPath, file);
+      try {
+        const fileContent = fs2.readFileSync(filePath, "utf-8");
+        const tempData = JSON.parse(fileContent);
+        if (now - tempData.timestamp > _ConfigFileManager.TEMP_FILE_EXPIRATION_MS) {
+          fs2.unlinkSync(filePath);
+        }
+      } catch (error) {
+        fs2.unlinkSync(filePath);
+      }
+    }
+  }
 };
+__publicField(_ConfigFileManager, "TEMP_FILE_EXPIRATION_MS", 5 * 60 * 1e3);
+var ConfigFileManager = _ConfigFileManager;
 
 // node_modules/ora/index.js
 import process9 from "node:process";
@@ -40952,22 +41013,24 @@ var createAccount = (accountPrivateKey) => {
 // src/lib/actions/BaseAction.ts
 import { ethers } from "ethers";
 import { writeFileSync, existsSync, readFileSync } from "fs";
-var BaseAction = class extends ConfigFileManager {
+var _BaseAction = class _BaseAction extends ConfigFileManager {
   constructor() {
     super();
     __publicField(this, "spinner");
     __publicField(this, "_genlayerClient", null);
     this.spinner = ora({ text: "", spinner: "dots" });
+    this.cleanupExpiredTempFiles();
   }
   async decryptKeystore(keystoreData, attempt = 1) {
     try {
-      const message = attempt === 1 ? "Enter password to decrypt keystore:" : `Invalid password. Attempt ${attempt}/3 - 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);
+      this.storeTempFile(_BaseAction.TEMP_KEY_FILENAME, wallet.privateKey);
       return wallet.privateKey;
     } catch (error) {
-      if (attempt >= 3) {
-        this.failSpinner("Maximum password attempts exceeded (3/3).");
+      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);
@@ -40984,31 +41047,47 @@ var BaseAction = class extends ConfigFileManager {
     }
     return inspect(data, { depth: null, colors: false });
   }
-  async getClient(rpcUrl) {
+  async getClient(rpcUrl, readOnly = false) {
     if (!this._genlayerClient) {
       const networkConfig = this.getConfig().network;
       const network = networkConfig ? JSON.parse(networkConfig) : localnet;
+      const account = await this.getAccount(readOnly);
       this._genlayerClient = createClient2({
         chain: network,
         endpoint: rpcUrl,
-        account: createAccount(await this.getPrivateKey())
+        account
       });
     }
     return this._genlayerClient;
   }
-  async getPrivateKey() {
-    const keypairPath = this.getConfigByKey("keyPairPath");
+  async getAccount(readOnly = false) {
+    let keypairPath = this.getConfigByKey("keyPairPath");
+    let decryptedPrivateKey;
+    let keystoreData;
     if (!keypairPath || !existsSync(keypairPath)) {
       await this.confirmPrompt("Keypair file not found. Would you like to create a new keypair?");
-      return await this.createKeypair("./keypair.json", false);
+      decryptedPrivateKey = await this.createKeypair(_BaseAction.DEFAULT_KEYSTORE_PATH, false);
+      keypairPath = this.getConfigByKey("keyPairPath");
     }
-    const keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+    keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
     if (!this.isValidKeystoreFormat(keystoreData)) {
       this.failSpinner("Invalid keystore format. Expected encrypted keystore file.");
       await this.confirmPrompt("Would you like to create a new keypair?");
-      return await this.createKeypair("./keypair.json", true);
+      decryptedPrivateKey = await this.createKeypair(_BaseAction.DEFAULT_KEYSTORE_PATH, true);
+      keypairPath = this.getConfigByKey("keyPairPath");
+      keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+    }
+    if (readOnly) {
+      return this.getAddress(keystoreData);
     }
-    return await this.decryptKeystore(keystoreData);
+    if (!decryptedPrivateKey) {
+      const cachedKey = this.getTempFile(_BaseAction.TEMP_KEY_FILENAME);
+      decryptedPrivateKey = cachedKey ? cachedKey : await this.decryptKeystore(keystoreData);
+    }
+    return createAccount(decryptedPrivateKey);
+  }
+  getAddress(keystoreData) {
+    return keystoreData.address;
   }
   async createKeypair(outputPath, overwrite) {
     const finalOutputPath = this.getFilePath(outputPath);
@@ -41024,8 +41103,8 @@ var BaseAction = class extends ConfigFileManager {
       this.failSpinner("Passwords do not match");
       process.exit(1);
     }
-    if (password.length < 8) {
-      this.failSpinner("Password must be at least 8 characters long");
+    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);
@@ -41036,6 +41115,7 @@ var BaseAction = class extends ConfigFileManager {
     };
     writeFileSync(finalOutputPath, JSON.stringify(keystoreData, null, 2));
     this.writeConfig("keyPairPath", finalOutputPath);
+    this.clearTempFile(_BaseAction.TEMP_KEY_FILENAME);
     return wallet.privateKey;
   }
   async promptPassword(message) {
@@ -41115,6 +41195,11 @@ ${message}`));
     this.spinner.text = source_default.blue(message);
   }
 };
+__publicField(_BaseAction, "DEFAULT_KEYSTORE_PATH", "./keypair.json");
+__publicField(_BaseAction, "MAX_PASSWORD_ATTEMPTS", 3);
+__publicField(_BaseAction, "MIN_PASSWORD_LENGTH", 8);
+__publicField(_BaseAction, "TEMP_KEY_FILENAME", "decrypted_private_key");
+var BaseAction = _BaseAction;
 
 // src/commands/update/ollama.ts
 var OllamaAction = class extends BaseAction {
@@ -41939,6 +42024,16 @@ Run npm install -g genlayer to update
       await image.remove({ force: true });
     }
   }
+  async resetDockerVolumes() {
+    const volumes = await this.docker.listVolumes();
+    const genlayerVolumes = volumes.Volumes?.filter(
+      (volume) => volume.Name.startsWith("genlayer_")
+    ) || [];
+    for (const volumeInfo of genlayerVolumes) {
+      const volume = this.docker.getVolume(volumeInfo.Name);
+      await volume.remove({ force: true });
+    }
+  }
   async cleanDatabase() {
     try {
       await rpcClient.request({ method: "sim_clearDbTables", params: [["current_state", "transactions"]] });
@@ -42038,12 +42133,13 @@ var InitAction = class extends BaseAction {
         return;
       }
       this.stopSpinner();
-      const confirmMessage = isRunning ? `GenLayer Localnet is already running and this command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?` : `This command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`;
+      const confirmMessage = isRunning ? `GenLayer Localnet is already running and this command is going to reset GenLayer docker images, containers and volumes, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?` : `This command is going to reset GenLayer docker images, containers and volumes, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`;
       await this.confirmPrompt(confirmMessage);
       this.logInfo(`Initializing GenLayer CLI with ${options.numValidators} validators`);
-      this.startSpinner("Resetting Docker containers and images...");
+      this.startSpinner("Resetting Docker containers, images, and volumes...");
       await this.simulatorService.resetDockerContainers();
       await this.simulatorService.resetDockerImages();
+      await this.simulatorService.resetDockerVolumes();
       this.stopSpinner();
       const llmQuestions = [
         {
@@ -42407,7 +42503,7 @@ var CallAction = class extends BaseAction {
     args,
     rpc
   }) {
-    const client = await this.getClient(rpc);
+    const client = await this.getClient(rpc, true);
     await client.initializeConsensusSmartContract();
     this.startSpinner(`Calling method ${method} on contract at ${contractAddress}...`);
     try {

package/docker-compose.yml

@@ -143,7 +143,12 @@ services:
     volumes:
       - hardhat_artifacts:/app/artifacts
       - hardhat_deployments:/app/deployments
+      - hardhat_cache:/app/cache
+      - hardhat_snapshots:/app/snapshots
 
 volumes:
   hardhat_artifacts:
-  hardhat_deployments:
+  hardhat_deployments:
+  hardhat_cache:
+  hardhat_snapshots:
+  

package/package.json

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

package/src/commands/contracts/call.ts

@@ -21,7 +21,7 @@ export class CallAction extends BaseAction {
     args: any[];
     rpc?: string;
   }): Promise<void> {
-    const client = await this.getClient(rpc);
+    const client = await this.getClient(rpc, true);
     await client.initializeConsensusSmartContract();
     this.startSpinner(`Calling method ${method} on contract at ${contractAddress}...`);
 

package/src/commands/general/init.ts

@@ -76,17 +76,18 @@ export class InitAction extends BaseAction {
       this.stopSpinner();
 
       const confirmMessage = isRunning
-        ? `GenLayer Localnet is already running and this command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`
-        : `This command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`;
+        ? `GenLayer Localnet is already running and this command is going to reset GenLayer docker images, containers and volumes, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`
+        : `This command is going to reset GenLayer docker images, containers and volumes, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?`;
 
       await this.confirmPrompt(confirmMessage);
 
       this.logInfo(`Initializing GenLayer CLI with ${options.numValidators} validators`);
 
-      // Reset Docker containers and images
-      this.startSpinner("Resetting Docker containers and images...");
+      // Reset Docker containers, images, and volumes
+      this.startSpinner("Resetting Docker containers, images, and volumes...");
       await this.simulatorService.resetDockerContainers();
       await this.simulatorService.resetDockerImages();
+      await this.simulatorService.resetDockerVolumes();
       this.stopSpinner();
 
       const llmQuestions: DistinctQuestion[] = [

package/src/lib/actions/BaseAction.ts

@@ -5,31 +5,40 @@ import inquirer from "inquirer";
 import { inspect } from "util";
 import {createClient, createAccount} from "genlayer-js";
 import {localnet} from "genlayer-js/chains";
-import type {GenLayerClient, GenLayerChain} from "genlayer-js/types";
+import type {GenLayerClient, GenLayerChain, Hash, Address, Account} from "genlayer-js/types";
 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 MAX_PASSWORD_ATTEMPTS = 3;
+  private static readonly MIN_PASSWORD_LENGTH = 8;
+  private static readonly TEMP_KEY_FILENAME = "decrypted_private_key";
+
   private spinner: Ora;
   private _genlayerClient: GenLayerClient<GenLayerChain> | null = null;
 
   constructor() {
     super();
     this.spinner = ora({text: "", spinner: "dots"});
+    this.cleanupExpiredTempFiles();
   }
 
   private async decryptKeystore(keystoreData: KeystoreData, attempt: number = 1): Promise<string> {
     try {
       const message = attempt === 1 
         ? "Enter password to decrypt keystore:" 
-        : `Invalid password. Attempt ${attempt}/3 - 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);
+      
+      this.storeTempFile(BaseAction.TEMP_KEY_FILENAME, wallet.privateKey);
+      
       return wallet.privateKey;
     } catch (error) {
-      if (attempt >= 3) {
-        this.failSpinner("Maximum password attempts exceeded (3/3).");
+      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);
@@ -52,36 +61,54 @@ export class BaseAction extends ConfigFileManager {
     return inspect(data, { depth: null, colors: false });
   }
 
-  protected async getClient(rpcUrl?: string): Promise<GenLayerClient<GenLayerChain>> {
+  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 account = await this.getAccount(readOnly);
       this._genlayerClient = createClient({
         chain: network,
         endpoint: rpcUrl,
-        account: createAccount((await this.getPrivateKey()) as any),
+        account: account,
       });
     }
     return this._genlayerClient;
   }
 
-  protected async getPrivateKey(): Promise<string> {
-    const keypairPath = this.getConfigByKey("keyPairPath");
+  private async getAccount(readOnly: boolean = false): Promise<Account | Address> {
+    let keypairPath = this.getConfigByKey("keyPairPath");
+    let decryptedPrivateKey;
+    let keystoreData;
 
     if (!keypairPath || !existsSync(keypairPath)) {
       await this.confirmPrompt("Keypair file not found. Would you like to create a new keypair?");
-      return await this.createKeypair("./keypair.json", false);
+      decryptedPrivateKey = await this.createKeypair(BaseAction.DEFAULT_KEYSTORE_PATH, false);
+      keypairPath = this.getConfigByKey("keyPairPath")!;
     }
 
-    const keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+    keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
 
     if (!this.isValidKeystoreFormat(keystoreData)) {
       this.failSpinner("Invalid keystore format. Expected encrypted keystore file.");
       await this.confirmPrompt("Would you like to create a new keypair?");
-      return await this.createKeypair("./keypair.json", true);
+      decryptedPrivateKey = await this.createKeypair(BaseAction.DEFAULT_KEYSTORE_PATH, true);
+      keypairPath = this.getConfigByKey("keyPairPath")!;
+      keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
     }
 
-    return await this.decryptKeystore(keystoreData);
+    if (readOnly) {
+      return this.getAddress(keystoreData);
+    }
+    
+    if (!decryptedPrivateKey) {
+      const cachedKey = this.getTempFile(BaseAction.TEMP_KEY_FILENAME);
+      decryptedPrivateKey = cachedKey ? cachedKey : await this.decryptKeystore(keystoreData);
+    }
+    return createAccount(decryptedPrivateKey as Hash);
+  }
+
+  private getAddress(keystoreData: KeystoreData): Address {
+    return keystoreData.address as Address;
   }
 
   protected async createKeypair(outputPath: string, overwrite: boolean): Promise<string> {
@@ -103,8 +130,8 @@ export class BaseAction extends ConfigFileManager {
       process.exit(1);
     }
 
-    if (password.length < 8) {
-      this.failSpinner("Password must be at least 8 characters long");
+    if (password.length < BaseAction.MIN_PASSWORD_LENGTH) {
+      this.failSpinner(`Password must be at least ${BaseAction.MIN_PASSWORD_LENGTH} characters long`);
       process.exit(1);
     }
 
@@ -119,6 +146,8 @@ export class BaseAction extends ConfigFileManager {
     writeFileSync(finalOutputPath, JSON.stringify(keystoreData, null, 2));
     this.writeConfig('keyPairPath', finalOutputPath);
     
+    this.clearTempFile(BaseAction.TEMP_KEY_FILENAME);
+    
     return wallet.privateKey;
   }
 

package/src/lib/config/ConfigFileManager.ts

@@ -2,15 +2,24 @@ import path from "path";
 import os from "os";
 import fs from "fs";
 
+interface TempFileData {
+  content: string;
+  timestamp: number;
+}
+
 export class ConfigFileManager {
   private folderPath: string;
   private configFilePath: string;
+  private tempFolderPath: string;
+  private static readonly TEMP_FILE_EXPIRATION_MS = 5 * 60 * 1000; // 5 minutes
 
   constructor(baseFolder: string = ".genlayer/", configFileName: string = "genlayer-config.json") {
     this.folderPath = path.resolve(os.homedir(), baseFolder);
     this.configFilePath = path.resolve(this.folderPath, configFileName);
+    this.tempFolderPath = path.resolve(os.tmpdir(), "genlayer-temp");
     this.ensureFolderExists();
     this.ensureConfigFileExists();
+    this.ensureTempFolderExists();
   }
 
   private ensureFolderExists(): void {
@@ -25,6 +34,12 @@ export class ConfigFileManager {
     }
   }
 
+  private ensureTempFolderExists(): void {
+    if (!fs.existsSync(this.tempFolderPath)) {
+      fs.mkdirSync(this.tempFolderPath, { recursive: true, mode: 0o700 }); // Owner-only access
+    }
+  }
+
   getFolderPath(): string {
     return this.folderPath;
   }
@@ -48,4 +63,67 @@ export class ConfigFileManager {
     config[key] = value;
     fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
   }
+
+  storeTempFile(fileName: string, content: string): void {
+    this.ensureTempFolderExists();
+    const filePath = path.resolve(this.tempFolderPath, fileName);
+    const tempData: TempFileData = {
+      content,
+      timestamp: Date.now()
+    };
+    fs.writeFileSync(filePath, JSON.stringify(tempData), { mode: 0o600 }); // Owner-only access
+  }
+
+  getTempFile(fileName: string): string | null {
+    const filePath = path.resolve(this.tempFolderPath, fileName);
+    
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    const fileContent = fs.readFileSync(filePath, "utf-8");
+    const tempData: TempFileData = JSON.parse(fileContent);
+    
+    if (Date.now() - tempData.timestamp > ConfigFileManager.TEMP_FILE_EXPIRATION_MS) {
+      this.clearTempFile(fileName);
+      return null;
+    }
+
+    return tempData.content;
+  }
+
+  hasTempFile(fileName: string): boolean {
+    return this.getTempFile(fileName) !== null;
+  }
+
+  clearTempFile(fileName: string): void {
+    const filePath = path.resolve(this.tempFolderPath, fileName);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  }
+
+  cleanupExpiredTempFiles(): void {
+    if (!fs.existsSync(this.tempFolderPath)) {
+      return;
+    }
+
+    const files = fs.readdirSync(this.tempFolderPath);
+    const now = Date.now();
+
+    for (const file of files) {
+      const filePath = path.resolve(this.tempFolderPath, file);
+
+      try {
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        const tempData: TempFileData = JSON.parse(fileContent);
+        
+        if (now - tempData.timestamp > ConfigFileManager.TEMP_FILE_EXPIRATION_MS) {
+          fs.unlinkSync(filePath);
+        }
+      } catch (error) {
+        fs.unlinkSync(filePath);
+      }
+    }
+  }
 }

package/src/lib/interfaces/ISimulatorService.ts

@@ -15,6 +15,7 @@ export interface ISimulatorService {
   stopDockerContainers(): Promise<void>;
   resetDockerContainers(): Promise<void>;
   resetDockerImages(): Promise<void>;
+  resetDockerVolumes(): Promise<void>;
   checkCliVersion(): Promise<void>;
   cleanDatabase(): Promise<boolean>;
   addConfigToEnvFile(newConfig: Record<string, string>): void;

package/src/lib/services/simulator.ts

@@ -278,6 +278,18 @@ export class SimulatorService implements ISimulatorService {
     }
   }
 
+  public async resetDockerVolumes(): Promise<void> {
+    const volumes = await this.docker.listVolumes();
+    const genlayerVolumes = volumes.Volumes?.filter(volume =>
+      volume.Name.startsWith('genlayer_')
+    ) || [];
+
+    for (const volumeInfo of genlayerVolumes) {
+      const volume = this.docker.getVolume(volumeInfo.Name);
+      await volume.remove({force: true});
+    }
+  }
+
   public async cleanDatabase(): Promise<boolean> {
 
     try {

package/tests/actions/appeal.test.ts

@@ -21,7 +21,7 @@ describe("AppealAction", () => {
     vi.mocked(createClient).mockReturnValue(mockClient as any);
     vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
     appealAction = new AppealAction();
-    vi.spyOn(appealAction as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
+    vi.spyOn(appealAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
 
     vi.spyOn(appealAction as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(appealAction as any, "succeedSpinner").mockImplementation(() => {});

package/tests/actions/call.test.ts

@@ -21,7 +21,7 @@ describe("CallAction", () => {
     vi.mocked(createClient).mockReturnValue(mockClient as any);
     vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
     callActions = new CallAction();
-    vi.spyOn(callActions as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
+    vi.spyOn(callActions as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
 
     vi.spyOn(callActions as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(callActions as any, "succeedSpinner").mockImplementation(() => {});

package/tests/actions/deploy.test.ts

@@ -26,7 +26,7 @@ describe("DeployAction", () => {
     vi.mocked(createClient).mockReturnValue(mockClient as any);
     vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
     deployer = new DeployAction();
-    vi.spyOn(deployer as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
+    vi.spyOn(deployer as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
     vi.spyOn(deployer as any, "getConfig").mockReturnValue({});
 
     vi.spyOn(deployer as any, "startSpinner").mockImplementation(() => {});

package/tests/actions/init.test.ts

@@ -13,6 +13,7 @@ describe("InitAction", () => {
   let checkVersionRequirementsSpy: ReturnType<typeof vi.spyOn>;
   let resetDockerContainersSpy: ReturnType<typeof vi.spyOn>;
   let resetDockerImagesSpy: ReturnType<typeof vi.spyOn>;
+  let resetDockerVolumesSpy: ReturnType<typeof vi.spyOn>;
   let addConfigToEnvFileSpy: ReturnType<typeof vi.spyOn>;
   let runSimulatorSpy: ReturnType<typeof vi.spyOn>;
   let waitForSimulatorSpy: ReturnType<typeof vi.spyOn>;
@@ -57,6 +58,9 @@ describe("InitAction", () => {
     resetDockerImagesSpy = vi
       .spyOn(SimulatorService.prototype, "resetDockerImages")
       .mockResolvedValue(undefined);
+    resetDockerVolumesSpy = vi
+      .spyOn(SimulatorService.prototype, "resetDockerVolumes")
+      .mockResolvedValue(undefined);
     addConfigToEnvFileSpy = vi.spyOn(SimulatorService.prototype, "addConfigToEnvFile").mockResolvedValue();
     runSimulatorSpy = vi
       .spyOn(SimulatorService.prototype, "runSimulator")
@@ -98,7 +102,7 @@ describe("InitAction", () => {
       await initAction.execute(defaultOptions);
 
       expect(confirmPromptSpy).toHaveBeenCalledWith(
-        "GenLayer Localnet is already running and this command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?",
+        "GenLayer Localnet is already running and this command is going to reset GenLayer docker images, containers and volumes, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?",
       );
     });
 
@@ -114,7 +118,7 @@ describe("InitAction", () => {
       await initAction.execute(defaultOptions);
 
       expect(confirmPromptSpy).toHaveBeenCalledWith(
-        "This command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?",
+        "This command is going to reset GenLayer docker images, containers and volumes, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?",
       );
     });
 
@@ -130,6 +134,7 @@ describe("InitAction", () => {
       expect(checkVersionRequirementsSpy).toHaveBeenCalled();
       expect(resetDockerContainersSpy).toHaveBeenCalled();
       expect(resetDockerImagesSpy).toHaveBeenCalled();
+      expect(resetDockerVolumesSpy).toHaveBeenCalled();
       expect(addConfigToEnvFileSpy).toHaveBeenCalledWith({
         OPENAIKEY: "API_KEY_OPENAI",
         HEURISTAIAPIKEY: "API_KEY_HEURIST",

package/tests/actions/receipt.test.ts

@@ -23,7 +23,7 @@ describe("ReceiptAction", () => {
     vi.mocked(createClient).mockReturnValue(mockClient as any);
     vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
     receiptAction = new ReceiptAction();
-    vi.spyOn(receiptAction as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
+    vi.spyOn(receiptAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
 
     vi.spyOn(receiptAction as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(receiptAction as any, "succeedSpinner").mockImplementation(() => {});

package/tests/actions/write.test.ts

@@ -19,7 +19,7 @@ describe("WriteAction", () => {
     vi.mocked(createClient).mockReturnValue(mockClient as any);
     vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
     writeAction = new WriteAction();
-    vi.spyOn(writeAction as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
+    vi.spyOn(writeAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
 
     vi.spyOn(writeAction as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(writeAction as any, "succeedSpinner").mockImplementation(() => {});

package/tests/libs/baseAction.test.ts

@@ -6,11 +6,20 @@ import chalk from "chalk";
 import {inspect} from "util";
 import { ethers } from "ethers";
 import { writeFileSync, existsSync, readFileSync } from "fs";
+import fs from "fs";
+import os from "os";
+import { createAccount } from "genlayer-js";
 
 vi.mock("inquirer");
 vi.mock("ora");
 vi.mock("fs");
+vi.mock("os");
 vi.mock("ethers");
+vi.mock("genlayer-js", () => ({
+  createAccount: vi.fn(),
+  createClient: vi.fn(),
+  localnet: {}
+}));
 
 describe("BaseAction", () => {
   let baseAction: BaseAction;
@@ -47,14 +56,25 @@ describe("BaseAction", () => {
     } as unknown as Ora;
 
     (ora as unknown as Mock).mockReturnValue(mockSpinner);
+    
+    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(os.tmpdir).mockReturnValue("/mocked/tmp");
+    
     vi.mocked(existsSync).mockReturnValue(true);
     vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockKeystoreData));
     vi.mocked(writeFileSync).mockImplementation(() => {});
+    vi.mocked(fs.readdirSync).mockReturnValue([] as any);
+    vi.mocked(fs.mkdirSync).mockImplementation(() => "/mocked/path");
 
     // Mock ethers
     vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet as any);
     vi.mocked(ethers.Wallet.fromEncryptedJson).mockResolvedValue(mockWallet as any);
 
+    vi.mocked(createAccount).mockReturnValue({
+      privateKey: mockWallet.privateKey,
+      address: mockWallet.address
+    } as any);
+
     baseAction = new BaseAction();
 
     // Mock config methods
@@ -62,6 +82,12 @@ describe("BaseAction", () => {
     vi.spyOn(baseAction as any, "getFilePath").mockImplementation(() => "./test-keypair.json");
     vi.spyOn(baseAction as any, "writeConfig").mockImplementation(() => {});
     vi.spyOn(baseAction as any, "getConfig").mockReturnValue({});
+    
+    // Mock temp file methods
+    vi.spyOn(baseAction as any, "storeTempFile").mockImplementation(() => {});
+    vi.spyOn(baseAction as any, "getTempFile").mockReturnValue(null);
+    vi.spyOn(baseAction as any, "clearTempFile").mockImplementation(() => {});
+    vi.spyOn(baseAction as any, "cleanupExpiredTempFiles").mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -226,9 +252,17 @@ describe("BaseAction", () => {
   test("should return private key when keystore exists and is valid", async () => {
     vi.mocked(inquirer.prompt).mockResolvedValue({password: "correct-password"});
 
-    const result = await baseAction["getPrivateKey"]();
+    const account = await baseAction["getAccount"](false);
 
-    expect(result).toBe(mockWallet.privateKey);
+    expect((account as any).privateKey).toBe(mockWallet.privateKey);
+    expect(existsSync).toHaveBeenCalledWith("./test-keypair.json");
+    expect(readFileSync).toHaveBeenCalledWith("./test-keypair.json", "utf-8");
+  });
+
+  test("should return address when called with readOnly=true", async () => {
+    const address = await baseAction["getAccount"](true);
+    
+    expect(address).toBe(mockKeystoreData.address);
     expect(existsSync).toHaveBeenCalledWith("./test-keypair.json");
     expect(readFileSync).toHaveBeenCalledWith("./test-keypair.json", "utf-8");
   });
@@ -240,9 +274,9 @@ describe("BaseAction", () => {
       .mockResolvedValueOnce({password: "new-password"}) // encrypt password
       .mockResolvedValueOnce({password: "new-password"}); // confirm password
 
-    const result = await baseAction["getPrivateKey"]();
+    const account = await baseAction["getAccount"](false);
 
-    expect(result).toBe(mockWallet.privateKey);
+    expect((account as any).privateKey).toBe(mockWallet.privateKey);
     expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
       expect.objectContaining({message: chalk.yellow("Keypair file not found. Would you like to create a new keypair?")})
     ]));
@@ -252,10 +286,20 @@ describe("BaseAction", () => {
     vi.mocked(readFileSync).mockReturnValue('{"invalid": "format"}');
     vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: false});
 
-    await expect(baseAction["getPrivateKey"]()).rejects.toThrow("process exited");
+    await expect(baseAction["getAccount"](false)).rejects.toThrow("process exited");
     expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Invalid keystore format. Expected encrypted keystore file."));
   });
 
+  test("should use cached key when available", async () => {
+    vi.spyOn(baseAction as any, "getTempFile").mockReturnValue(mockWallet.privateKey);
+
+    const account = await baseAction["getAccount"](false);
+
+    expect((account as any).privateKey).toBe(mockWallet.privateKey);
+    expect(baseAction["getTempFile"]).toHaveBeenCalledWith("decrypted_private_key");
+    expect(inquirer.prompt).not.toHaveBeenCalled();
+  });
+
   test("should create new keypair when keystore format is invalid and user confirms", async () => {
     vi.mocked(readFileSync).mockReturnValue('{"invalid": "format"}');
     vi.mocked(inquirer.prompt)
@@ -263,9 +307,9 @@ describe("BaseAction", () => {
       .mockResolvedValueOnce({password: "new-password"})
       .mockResolvedValueOnce({password: "new-password"});
 
-    const result = await baseAction["getPrivateKey"]();
+    const account = await baseAction["getAccount"](false);
 
-    expect(result).toBe(mockWallet.privateKey);
+    expect((account as any).privateKey).toBe(mockWallet.privateKey);
     expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Invalid keystore format. Expected encrypted keystore file."));
     expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
       expect.objectContaining({message: chalk.yellow("Would you like to create a new keypair?")})

package/tests/libs/configFileManager.test.ts

@@ -11,12 +11,14 @@ vi.mock("os")
 describe("ConfigFileManager", () => {
   const mockFolderPath = "/mocked/home/.genlayer";
   const mockConfigFilePath = `${mockFolderPath}/genlayer-config.json`;
+  const mockTempFolderPath = "/mocked/tmp/genlayer-temp";
 
   let configFileManager: ConfigFileManager;
 
   beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+    vi.mocked(os.tmpdir).mockReturnValue("/mocked/tmp");
     configFileManager = new ConfigFileManager();
   });
 
@@ -99,15 +101,215 @@ describe("ConfigFileManager", () => {
   });
 
   test("writeConfig overwrites an existing key in the config file", () => {
-    const mockConfig = { existingKey: "existingValue" };
-    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+    const existingConfig = { existingKey: "existingValue" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(existingConfig));
 
-    configFileManager.writeConfig("existingKey", "updatedValue");
+    configFileManager.writeConfig("existingKey", "newValue");
 
-    const expectedConfig = { existingKey: "updatedValue" };
-    expect(fs.writeFileSync).toHaveBeenCalledWith(
-      mockConfigFilePath,
-      JSON.stringify(expectedConfig, null, 2)
-    );
+    const expectedConfig = { existingKey: "newValue" };
+    expect(fs.writeFileSync).toHaveBeenCalledWith(mockConfigFilePath, JSON.stringify(expectedConfig, null, 2));
+  });
+
+  describe("Temp File Operations", () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+      vi.mocked(os.homedir).mockReturnValue("/mocked/home");
+      vi.mocked(os.tmpdir).mockReturnValue("/mocked/tmp");
+      configFileManager = new ConfigFileManager();
+    });
+
+    test("storeTempFile creates temp folder and stores file with timestamp", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      const mockTimestamp = 1234567890;
+      vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+
+      configFileManager.storeTempFile("test.json", "test content");
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp", { recursive: true, mode: 0o700 });
+      
+      const expectedData = {
+        content: "test content",
+        timestamp: mockTimestamp
+      };
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        "/mocked/tmp/genlayer-temp/test.json", 
+        JSON.stringify(expectedData), 
+        { mode: 0o600 }
+      );
+    });
+
+    test("storeTempFile does not create temp folder when it already exists", () => {
+      vi.clearAllMocks();
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        if (path === "/mocked/home/.genlayer") return true;
+        if (path === "/mocked/tmp/genlayer-temp") return true;
+        return false;
+      });
+      
+      const testConfigManager = new ConfigFileManager();
+      
+      const mockTimestamp = 1234567890;
+      vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+
+      testConfigManager.storeTempFile("test.json", "test content");
+
+      expect(fs.mkdirSync).not.toHaveBeenCalled();
+      
+      const expectedData = {
+        content: "test content",
+        timestamp: mockTimestamp
+      };
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        "/mocked/tmp/genlayer-temp/test.json", 
+        JSON.stringify(expectedData), 
+        { mode: 0o600 }
+      );
+    });
+
+    test("getTempFile returns content when file exists and is not expired", () => {
+      const mockTimestamp = Date.now() - 60000; // 1 minute ago
+      const mockFileData = {
+        content: "cached content",
+        timestamp: mockTimestamp
+      };
+      
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockFileData));
+
+      const result = configFileManager.getTempFile("test.json");
+
+      expect(result).toBe("cached content");
+      expect(fs.existsSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/test.json");
+      expect(fs.readFileSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/test.json", "utf-8");
+    });
+
+    test("getTempFile returns null when file does not exist", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      const result = configFileManager.getTempFile("nonexistent.json");
+
+      expect(result).toBeNull();
+      expect(fs.existsSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/nonexistent.json");
+    });
+
+    test("getTempFile returns null and clears file when expired", () => {
+      const expiredTimestamp = Date.now() - (6 * 60 * 1000); // 6 minutes ago (expired)
+      const mockFileData = {
+        content: "expired content",
+        timestamp: expiredTimestamp
+      };
+      
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockFileData));
+
+      const result = configFileManager.getTempFile("expired.json");
+
+      expect(result).toBeNull();
+      expect(fs.unlinkSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/expired.json");
+    });
+
+    test("hasTempFile returns true when valid temp file exists", () => {
+      const mockTimestamp = Date.now() - 60000; // 1 minute ago
+      const mockFileData = {
+        content: "test content",
+        timestamp: mockTimestamp
+      };
+      
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockFileData));
+
+      const result = configFileManager.hasTempFile("test.json");
+
+      expect(result).toBe(true);
+    });
+
+    test("hasTempFile returns false when temp file is expired", () => {
+      const expiredTimestamp = Date.now() - (6 * 60 * 1000); // 6 minutes ago
+      const mockFileData = {
+        content: "expired content",
+        timestamp: expiredTimestamp
+      };
+      
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockFileData));
+
+      const result = configFileManager.hasTempFile("expired.json");
+
+      expect(result).toBe(false);
+    });
+
+    test("clearTempFile removes specific temp file", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+
+      configFileManager.clearTempFile("test.json");
+
+      expect(fs.existsSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/test.json");
+      expect(fs.unlinkSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/test.json");
+    });
+
+    test("clearTempFile does nothing when file does not exist", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      configFileManager.clearTempFile("nonexistent.json");
+
+      expect(fs.existsSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/nonexistent.json");
+      expect(fs.unlinkSync).not.toHaveBeenCalled();
+    });
+
+    test("cleanupExpiredTempFiles removes only expired files", () => {
+      const now = Date.now();
+      const validTimestamp = now - 60000; // 1 minute ago (valid)
+      const expiredTimestamp = now - (6 * 60 * 1000); // 6 minutes ago (expired)
+      
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readdirSync).mockReturnValue(['valid.json', 'expired.json'] as any);
+      
+      vi.mocked(fs.readFileSync)
+        .mockReturnValueOnce(JSON.stringify({content: "valid", timestamp: validTimestamp}))
+        .mockReturnValueOnce(JSON.stringify({content: "expired", timestamp: expiredTimestamp}));
+      
+      vi.spyOn(Date, 'now').mockReturnValue(now);
+
+      configFileManager.cleanupExpiredTempFiles();
+
+      expect(fs.readdirSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp");
+      expect(fs.readFileSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/valid.json", "utf-8");
+      expect(fs.readFileSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/expired.json", "utf-8");
+      expect(fs.unlinkSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/expired.json");
+      expect(fs.unlinkSync).toHaveBeenCalledTimes(1); // Only expired file should be deleted
+    });
+
+    test("cleanupExpiredTempFiles removes corrupted files that cannot be parsed", () => {
+      const now = Date.now();
+      const validTimestamp = now - 60000; // 1 minute ago (valid)
+      
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readdirSync).mockReturnValue(['valid.json', 'corrupted.json'] as any);
+      
+      vi.mocked(fs.readFileSync)
+        .mockReturnValueOnce(JSON.stringify({content: "valid", timestamp: validTimestamp}))
+        .mockReturnValueOnce("invalid json content");
+      
+      vi.spyOn(Date, 'now').mockReturnValue(now);
+
+      configFileManager.cleanupExpiredTempFiles();
+
+      expect(fs.readdirSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp");
+      expect(fs.readFileSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/valid.json", "utf-8");
+      expect(fs.readFileSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/corrupted.json", "utf-8");
+      
+      // The corrupted file should be deleted due to JSON.parse error
+      expect(fs.unlinkSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp/corrupted.json");
+      expect(fs.unlinkSync).toHaveBeenCalledTimes(1); // Only corrupted file should be deleted
+    });
+
+    test("cleanupExpiredTempFiles does nothing when temp folder does not exist", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      configFileManager.cleanupExpiredTempFiles();
+
+      expect(fs.existsSync).toHaveBeenCalledWith("/mocked/tmp/genlayer-temp");
+      expect(fs.readdirSync).not.toHaveBeenCalled();
+    });
   });
 });

package/tests/services/simulator.test.ts

@@ -499,6 +499,46 @@ describe("SimulatorService - Docker Tests", () => {
     expect(mockRemove).toHaveBeenCalledWith({force: true});
   });
 
+  test("should remove Docker volumes with genlayer_ prefix", async () => {
+    const mockVolumes = {
+      Volumes: [
+        { Name: "genlayer_volume1" },
+        { Name: "genlayer_postgres" },
+        { Name: "genlayer_data" },
+        { Name: "unrelated_volume" },
+        { Name: "another_volume" },
+        { Name: "hardhat_artifacts" },
+      ],
+      Warnings: [],
+    };
+
+    const mockListVolumes = vi.mocked(Docker.prototype.listVolumes);
+    const mockGetVolume = vi.mocked(Docker.prototype.getVolume);
+    
+    mockListVolumes.mockResolvedValue(mockVolumes as any);
+
+    const mockRemove = vi.fn().mockResolvedValue(undefined);
+    mockGetVolume.mockImplementation(
+      () =>
+        ({
+          remove: mockRemove,
+        }) as unknown as Docker.Volume,
+    );
+
+    const result = await simulatorService.resetDockerVolumes();
+
+    expect(result).toBe(undefined);
+    expect(mockListVolumes).toHaveBeenCalled();
+    expect(mockGetVolume).toHaveBeenCalledWith("genlayer_volume1");
+    expect(mockGetVolume).toHaveBeenCalledWith("genlayer_postgres");
+    expect(mockGetVolume).toHaveBeenCalledWith("genlayer_data");
+    expect(mockGetVolume).not.toHaveBeenCalledWith("unrelated_volume");
+    expect(mockGetVolume).not.toHaveBeenCalledWith("another_volume");
+    expect(mockGetVolume).not.toHaveBeenCalledWith("hardhat_artifacts");
+    expect(mockRemove).toHaveBeenCalledTimes(3);
+    expect(mockRemove).toHaveBeenCalledWith({force: true});
+  });
+
   test("should execute command when docker is installed but is not available", async () => {
     vi.mocked(checkCommand).mockResolvedValueOnce(undefined);