genlayer 0.24.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.26.0 (2025-08-07)
+
+### Features
+
+* add schema command to inspect deployed contract schema ([#244](https://github.com/yeagerai/genlayer-cli/issues/244)) ([4d66a7b](https://github.com/yeagerai/genlayer-cli/commit/4d66a7b9b2ac813cf0d47f12fc82cbc06ed25b3c))
+
+## 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

package/README.md

@@ -146,6 +146,7 @@ USAGE:
    genlayer deploy [options]
    genlayer call <contractAddress> <method> [options]
    genlayer write <contractAddress> <method> [options]
+   genlayer schema <contractAddress> [options]
 
 OPTIONS (deploy):
    --contract <contractPath>  (Optional) Path to the intelligent contract to deploy
@@ -160,12 +161,16 @@ OPTIONS (write):
    --rpc <rpcUrl>             RPC URL for the network
    --args <args...>           Positional arguments for the method (space-separated, use quotes for multi-word arguments)
 
+OPTIONS (schema):
+   --rpc <rpcUrl>             RPC URL for the network
+
 EXAMPLES:
    genlayer deploy
    genlayer deploy --contract ./my_contract.gpy
    genlayer deploy --contract ./my_contract.gpy --args "arg1" "arg2" 123
    genlayer call 0x123456789abcdef greet --args "Hello World!"
    genlayer write 0x123456789abcdef updateValue --args 42
+   genlayer schema 0x123456789abcdef
 ```
 
 ##### Deploy Behavior
@@ -176,6 +181,9 @@ EXAMPLES:
 - `call` - Calls a contract method without sending a transaction or changing the state (read-only)
 - `write` - Sends a transaction to a contract method that modifies the state
 
+##### Schema
+- `schema` - Retrieves the contract schema
+
 #### Keypair Management
 
 Generate and manage keypairs.

package/dist/index.js

@@ -17856,7 +17856,7 @@ var require_semver2 = __commonJS({
 import { program } from "commander";
 
 // package.json
-var version = "0.24.0";
+var version = "0.26.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 {
@@ -42418,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 {
@@ -42468,6 +42553,27 @@ var WriteAction = class extends BaseAction {
   }
 };
 
+// src/commands/contracts/schema.ts
+var SchemaAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  async schema({
+    contractAddress,
+    rpc
+  }) {
+    const client = await this.getClient(rpc, true);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Getting schema for contract at ${contractAddress}...`);
+    try {
+      const result = await client.getContractSchema(contractAddress);
+      this.succeedSpinner("Contract schema retrieved successfully", result);
+    } catch (error) {
+      this.failSpinner("Error retrieving contract schema", error);
+    }
+  }
+};
+
 // src/commands/contracts/index.ts
 function parseArg(value, previous = []) {
   if (value === "true") return [...previous, true];
@@ -42496,8 +42602,8 @@ function initializeContractsCommands(program2) {
     parseArg,
     []
   ).action(async (contractAddress, method, options) => {
-    const caller = new CallAction();
-    await caller.call({ contractAddress, method, ...options });
+    const callAction = new CallAction();
+    await callAction.call({ contractAddress, method, ...options });
   });
   program2.command("write <contractAddress> <method>").description("Sends a transaction to a contract method that modifies the state").option("--rpc <rpcUrl>", "RPC URL for the network").option(
     "--args <args...>",
@@ -42505,8 +42611,12 @@ function initializeContractsCommands(program2) {
     parseArg,
     []
   ).action(async (contractAddress, method, options) => {
-    const writer = new WriteAction();
-    await writer.write({ contractAddress, method, ...options });
+    const writeAction = new WriteAction();
+    await writeAction.write({ contractAddress, method, ...options });
+  });
+  program2.command("schema <contractAddress>").description("Get the schema for a deployed contract").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (contractAddress, options) => {
+    const schemaAction = new SchemaAction();
+    await schemaAction.schema({ contractAddress, ...options });
   });
   return program2;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.24.0",
+  "version": "0.26.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/contracts/index.ts

@@ -2,6 +2,7 @@ import {Command} from "commander";
 import {DeployAction, DeployOptions, DeployScriptsOptions} from "./deploy";
 import {CallAction, CallOptions} from "./call";
 import {WriteAction, WriteOptions} from "./write";
+import {SchemaAction, SchemaOptions} from "./schema";
 
 function parseArg(value: string, previous: any[] = []): any[] {
   if (value === "true") return [...previous, true];
@@ -43,8 +44,8 @@ export function initializeContractsCommands(program: Command) {
       [],
     )
     .action(async (contractAddress: string, method: string, options: CallOptions) => {
-      const caller = new CallAction();
-      await caller.call({contractAddress, method, ...options});
+      const callAction = new CallAction();
+      await callAction.call({contractAddress, method, ...options});
     });
 
   program
@@ -58,8 +59,17 @@ export function initializeContractsCommands(program: Command) {
       [],
     )
     .action(async (contractAddress: string, method: string, options: WriteOptions) => {
-      const writer = new WriteAction();
-      await writer.write({contractAddress, method, ...options});
+      const writeAction = new WriteAction();
+      await writeAction.write({contractAddress, method, ...options});
+    });
+
+  program
+    .command("schema <contractAddress>")
+    .description("Get the schema for a deployed contract")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (contractAddress: string, options: SchemaOptions) => {
+      const schemaAction = new SchemaAction();
+      await schemaAction.schema({contractAddress, ...options});
     });
 
   return program;

package/src/commands/contracts/schema.ts

@@ -0,0 +1,31 @@
+import {BaseAction} from "../../lib/actions/BaseAction";
+import type {Address} from "genlayer-js/types";
+
+export interface SchemaOptions {
+  rpc?: string;
+}
+
+export class SchemaAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  async schema({
+    contractAddress,
+    rpc,
+  }: {
+    contractAddress: string;
+    rpc?: string;
+  }): Promise<void> {
+    const client = await this.getClient(rpc, true);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Getting schema for contract at ${contractAddress}...`);
+
+    try {
+      const result = await client.getContractSchema(contractAddress as Address);
+      this.succeedSpinner("Contract schema retrieved successfully", result);
+    } catch (error) {
+      this.failSpinner("Error retrieving contract schema", error);
+    }
+  }
+} 

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/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/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/schema.test.ts

@@ -0,0 +1,94 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import {SchemaAction} from "../../src/commands/contracts/schema";
+
+vi.mock("genlayer-js");
+
+describe("SchemaAction", () => {
+  let schemaAction: SchemaAction;
+  const mockClient = {
+    getContractSchema: 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);
+    schemaAction = new SchemaAction();
+    vi.spyOn(schemaAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(schemaAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(schemaAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(schemaAction as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(schemaAction as any, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("gets contract schema successfully", async () => {
+    const mockResult = {
+      methods: {
+        getData: {
+          params: [["value", "int"]],
+          ret: "int",
+          readonly: true,
+        },
+      },
+    };
+
+    vi.mocked(mockClient.getContractSchema).mockResolvedValue(mockResult);
+
+    await schemaAction.schema({
+      contractAddress: "0xMockedContract",
+    });
+
+    expect(mockClient.getContractSchema).toHaveBeenCalledWith("0xMockedContract");
+    expect(schemaAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Contract schema retrieved successfully",
+      mockResult,
+    );
+  });
+
+  test("handles getContractSchema errors", async () => {
+    vi.mocked(mockClient.getContractSchema).mockRejectedValue(new Error("Mocked schema error"));
+
+    await schemaAction.schema({contractAddress: "0xMockedContract"});
+
+    expect(schemaAction["failSpinner"]).toHaveBeenCalledWith("Error retrieving contract schema", expect.any(Error));
+  });
+
+  test("uses custom RPC URL when provided", async () => {
+    const mockResult = {methods: {}};
+    vi.mocked(mockClient.getContractSchema).mockResolvedValue(mockResult);
+
+    await schemaAction.schema({
+      contractAddress: "0xMockedContract",
+      rpc: "https://custom-rpc-url.com",
+    });
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: "https://custom-rpc-url.com",
+      }),
+    );
+    expect(mockClient.getContractSchema).toHaveBeenCalledWith("0xMockedContract");
+    expect(schemaAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Contract schema retrieved successfully",
+      mockResult,
+    );
+  });
+
+  test("initializes consensus smart contract", async () => {
+    const mockResult = {methods: {}};
+    vi.mocked(mockClient.getContractSchema).mockResolvedValue(mockResult);
+
+    await schemaAction.schema({contractAddress: "0xMockedContract"});
+
+    expect(mockClient.initializeConsensusSmartContract).toHaveBeenCalled();
+  });
+}); 

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/commands/schema.test.ts

@@ -0,0 +1,67 @@
+import { Command } from "commander";
+import { SchemaAction } from "../../src/commands/contracts/schema";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeContractsCommands } from "../../src/commands/contracts";
+
+vi.mock("../../src/commands/contracts/schema");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+describe("schema command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeContractsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("SchemaAction.schema is called with default options", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+    expect(SchemaAction.prototype.schema).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+    });
+  });
+
+  test("SchemaAction.schema is called with custom RPC URL", async () => {
+    program.parse([
+      "node",
+      "test",
+      "schema",
+      "0xMockedContract",
+      "--rpc",
+      "https://custom-rpc-url.com"
+    ]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+    expect(SchemaAction.prototype.schema).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      rpc: "https://custom-rpc-url.com"
+    });
+  });
+
+  test("SchemaAction is instantiated when the schema command is executed", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    expect(SchemaAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const schemaCommand = program.commands.find((cmd) => cmd.name() === "schema");
+    schemaCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "schema", "0xMockedContract", "--unknown"]))
+      .toThrowError("error: unknown option '--unknown'");
+  });
+
+  test("SchemaAction.schema is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "schema", "0xMockedContract"]);
+    vi.mocked(SchemaAction.prototype.schema).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "schema", "0xMockedContract"])
+    ).not.toThrow();
+  });
+}); 

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();
+    });
   });
 });