genlayer 0.38.8 → 0.38.10

package/src/lib/actions/BaseAction.ts

@@ -0,0 +1,301 @@
+import {ConfigFileManager} from "../../lib/config/ConfigFileManager";
+import {KeychainManager} from "../../lib/config/KeychainManager";
+import ora, {Ora} from "ora";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { inspect } from "util";
+import {createClient, createAccount} from "genlayer-js";
+import {localnet, studionet, testnetAsimov, testnetBradbury} from "genlayer-js/chains";
+import type {GenLayerClient, GenLayerChain, Hash, Address, Account} from "genlayer-js/types";
+
+// Built-in networks - always resolve fresh from genlayer-js
+export const BUILT_IN_NETWORKS: Record<string, GenLayerChain> = {
+  "localnet": localnet,
+  "studionet": studionet,
+  "testnet-asimov": testnetAsimov,
+  "testnet-bradbury": testnetBradbury,
+};
+
+/**
+ * Resolves a stored network config to a fresh chain object.
+ * Handles both new format (alias string) and old format (JSON object) for backwards compat.
+ */
+export function resolveNetwork(stored: string | undefined): GenLayerChain {
+  if (!stored) return localnet;
+
+  // Try as alias first (new format)
+  if (BUILT_IN_NETWORKS[stored]) {
+    return BUILT_IN_NETWORKS[stored];
+  }
+
+  // Backwards compat: try parsing as JSON (old format)
+  try {
+    const parsed = JSON.parse(stored);
+    // If it has a known name, use fresh version instead
+    const alias = Object.entries(BUILT_IN_NETWORKS)
+      .find(([_, chain]) => chain.name === parsed.name)?.[0];
+    if (alias) {
+      return BUILT_IN_NETWORKS[alias];
+    }
+    // Custom network - use as-is
+    return parsed;
+  } catch {
+    throw new Error(`Unknown network: ${stored}`);
+  }
+}
+import { ethers } from "ethers";
+import { writeFileSync, existsSync, readFileSync } from "fs";
+
+export class BaseAction extends ConfigFileManager {
+  private static readonly DEFAULT_ACCOUNT_NAME = "default";
+  private static readonly MAX_PASSWORD_ATTEMPTS = 3;
+  protected static readonly MIN_PASSWORD_LENGTH = 8;
+
+  private spinner: Ora;
+  private _genlayerClient: GenLayerClient<GenLayerChain> | null = null;
+  protected keychainManager: KeychainManager;
+  protected accountOverride: string | null = null;
+
+  constructor() {
+    super();
+    this.spinner = ora({text: "", spinner: "dots"});
+    this.keychainManager = new KeychainManager();
+  }
+
+  private async decryptKeystore(keystoreJson: string, attempt: number = 1): Promise<string> {
+    try {
+      const message = attempt === 1
+        ? "Enter password to decrypt keystore:"
+        : `Invalid password. Attempt ${attempt}/${BaseAction.MAX_PASSWORD_ATTEMPTS} - Enter password to decrypt keystore:`;
+      const password = await this.promptPassword(message);
+      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
+
+      return wallet.privateKey;
+    } catch (error) {
+      if (attempt >= BaseAction.MAX_PASSWORD_ATTEMPTS) {
+        this.failSpinner(`Maximum password attempts exceeded (${BaseAction.MAX_PASSWORD_ATTEMPTS}/${BaseAction.MAX_PASSWORD_ATTEMPTS}).`);
+      }
+      return await this.decryptKeystore(keystoreJson, attempt + 1);
+    }
+  }
+
+  protected isValidKeystoreFormat(data: any): boolean {
+    // Standard web3 keystore format has 'crypto' (or 'Crypto') and 'address' fields
+    return Boolean(
+      data &&
+      (data.crypto || data.Crypto) &&
+      typeof data.address === "string"
+    );
+  }
+
+  private formatOutput(data: any): string {
+    if (typeof data === "string") {
+      return data;
+    }
+    return inspect(data, { depth: null, colors: false });
+  }
+
+  protected async getClient(rpcUrl?: string, readOnly: boolean = false): Promise<GenLayerClient<GenLayerChain>> {
+    if (!this._genlayerClient) {
+      const network = resolveNetwork(this.getConfig().network);
+      const account = await this.getAccount(readOnly);
+      this._genlayerClient = createClient({
+        chain: network,
+        endpoint: rpcUrl,
+        account: account,
+      });
+    }
+    return this._genlayerClient;
+  }
+
+  protected resolveAccountName(): string {
+    // Priority: explicit override > config active account > default
+    if (this.accountOverride) {
+      return this.accountOverride;
+    }
+    const activeAccount = this.getActiveAccount();
+    if (activeAccount) {
+      return activeAccount;
+    }
+    return BaseAction.DEFAULT_ACCOUNT_NAME;
+  }
+
+  private async getAccount(readOnly: boolean = false): Promise<Account | Address> {
+    const accountName = this.resolveAccountName();
+    const keystorePath = this.getKeystorePath(accountName);
+    let decryptedPrivateKey;
+    let keystoreJson: string;
+    let keystoreData: any;
+
+    if (!existsSync(keystorePath)) {
+      await this.confirmPrompt(`Account '${accountName}' not found. Would you like to create it?`);
+      decryptedPrivateKey = await this.createKeypairByName(accountName, false);
+    }
+
+    keystoreJson = readFileSync(keystorePath, "utf-8");
+    keystoreData = JSON.parse(keystoreJson);
+
+    if (!this.isValidKeystoreFormat(keystoreData)) {
+      this.failSpinner("Invalid keystore format. Expected encrypted keystore file.", undefined, false);
+      await this.confirmPrompt(`Would you like to recreate account '${accountName}'?`);
+      decryptedPrivateKey = await this.createKeypairByName(accountName, true);
+      keystoreJson = readFileSync(keystorePath, "utf-8");
+      keystoreData = JSON.parse(keystoreJson);
+    }
+
+    if (readOnly) {
+      return this.getAddress(keystoreData);
+    }
+
+    if (!decryptedPrivateKey) {
+      const cachedKey = await this.keychainManager.getPrivateKey(accountName);
+      if (cachedKey) {
+        // Verify cached key matches keystore address
+        const tempAccount = createAccount(cachedKey as Hash);
+        const cachedAddress = tempAccount.address.toLowerCase();
+        const keystoreAddress = `0x${keystoreData.address.toLowerCase().replace(/^0x/, '')}`;
+        if (cachedAddress === keystoreAddress) {
+          decryptedPrivateKey = cachedKey;
+        } else {
+          // Cached key doesn't match keystore - invalidate it
+          await this.keychainManager.removePrivateKey(accountName);
+          decryptedPrivateKey = await this.decryptKeystore(keystoreJson);
+        }
+      } else {
+        decryptedPrivateKey = await this.decryptKeystore(keystoreJson);
+      }
+    }
+    return createAccount(decryptedPrivateKey as Hash);
+  }
+
+  private getAddress(keystoreData: any): Address {
+    const addr = keystoreData.address;
+    return (addr.startsWith('0x') ? addr : `0x${addr}`) as Address;
+  }
+
+  protected async createKeypairByName(accountName: string, overwrite: boolean, passwordInput?: string): Promise<string> {
+    const keystorePath = this.getKeystorePath(accountName);
+    this.stopSpinner();
+
+    if (existsSync(keystorePath) && !overwrite) {
+      this.failSpinner(`Account '${accountName}' already exists. Use '--overwrite' to replace it.`);
+    }
+
+    const wallet = ethers.Wallet.createRandom();
+
+    let password: string;
+    if (passwordInput) {
+      password = passwordInput;
+    } else {
+      password = await this.promptPassword("Enter a password to encrypt your keystore (minimum 8 characters):");
+      const confirmPassword = await this.promptPassword("Confirm password:");
+      if (password !== confirmPassword) {
+        this.failSpinner("Passwords do not match");
+      }
+    }
+
+    if (password.length < BaseAction.MIN_PASSWORD_LENGTH) {
+      this.failSpinner(`Password must be at least ${BaseAction.MIN_PASSWORD_LENGTH} characters long`);
+    }
+
+    // Write standard web3 keystore format directly
+    const encryptedJson = await wallet.encrypt(password);
+    writeFileSync(keystorePath, encryptedJson);
+
+    // Set as active account if no active account exists
+    if (!this.getActiveAccount()) {
+      this.setActiveAccount(accountName);
+    }
+
+    await this.keychainManager.removePrivateKey(accountName);
+
+    return wallet.privateKey;
+  }
+
+  protected async promptPassword(message: string): Promise<string> {
+    const answer = await inquirer.prompt([
+      {
+        type: "password",
+        name: "password",
+        message: chalk.yellow(message),
+        mask: "*",
+        validate: (input: string) => {
+          if (!input) {
+            return "Password cannot be empty";
+          }
+          return true;
+        },
+      },
+    ]);
+    return answer.password;
+  }
+
+  protected async confirmPrompt(message: string): Promise<void> {
+    const answer = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirmAction",
+        message: chalk.yellow(message),
+        default: true,
+      },
+    ]);
+
+    if (!answer.confirmAction) {
+      this.logError("Operation aborted!");
+      process.exit(0);
+    }
+  }
+
+  protected log(message: string, data?: any): void {
+    console.log(chalk.white(`\n${message}`));
+    if (data !== undefined) console.log(this.formatOutput(data));
+  }
+
+  protected logSuccess(message: string, data?: any): void {
+    console.log(chalk.green(`\n✔ ${message}`));
+    if (data !== undefined) console.log(chalk.green(this.formatOutput(data)));
+  }
+
+  protected logInfo(message: string, data?: any): void {
+    console.log(chalk.blue(`\nℹ ${message}`));
+    if (data !== undefined) console.log(chalk.blue(this.formatOutput(data)));
+  }
+
+  protected logWarning(message: string, data?: any): void {
+    console.log(chalk.yellow(`\n⚠ ${message}`));
+    if (data !== undefined) console.log(chalk.yellow(this.formatOutput(data)));
+  }
+
+  protected logError(message: string, error?: any): void {
+    console.error(chalk.red(`\n✖ ${message}`));
+    if (error !== undefined) console.error(chalk.red(this.formatOutput(error)));
+  }
+
+  protected startSpinner(message: string) {
+    this.spinner.text = chalk.blue(`${message}`);
+    this.spinner.start();
+  }
+
+  protected succeedSpinner(message: string, data?: any): void {
+    if (data !== undefined) this.log("Result:", data);
+    console.log('');
+    this.spinner.succeed(chalk.green(message));
+  }
+
+  protected failSpinner(message: string, error?: any, shouldExit = true): void {
+    if (error) this.log("Error:", error);
+    console.log("");
+    this.spinner.fail(chalk.red(message));
+    if (shouldExit) {
+      process.exit(1);
+    }
+  }
+
+  protected stopSpinner(): void {
+    this.spinner.stop();
+  }
+
+  protected setSpinnerText(message: string): void {
+    this.spinner.text = chalk.blue(message);
+  }
+}

package/src/lib/clients/jsonRpcClient.ts

@@ -0,0 +1,41 @@
+import fetch from "node-fetch";
+import {v4 as uuidv4} from "uuid";
+
+import {DEFAULT_JSON_RPC_URL} from "../config/simulator";
+
+export interface JsonRPCParams {
+  method: string;
+  params: any[];
+}
+
+export class JsonRpcClient {
+  serverUrl: string;
+
+  constructor(serverUrl: string) {
+    this.serverUrl = serverUrl;
+  }
+
+  async request({method, params}: JsonRPCParams): Promise<any | null> {
+    const response = await fetch(this.serverUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: uuidv4(),
+        method,
+        params,
+      }),
+    });
+
+    if (response.ok) {
+      return response.json();
+    }
+    const result = await response.json();
+
+    throw new Error(result?.error?.message || response.statusText);
+
+  }
+}
+export const rpcClient = new JsonRpcClient(DEFAULT_JSON_RPC_URL);

package/src/lib/clients/system.ts

@@ -0,0 +1,73 @@
+import util from "node:util";
+import {ChildProcess, exec} from "child_process";
+import open from "open";
+
+import {RunningPlatform, AVAILABLE_PLATFORMS} from "../config/simulator";
+import {MissingRequirementError} from "../errors/missingRequirement";
+
+export async function checkCommand(command: string, toolName: string): Promise<void> {
+  try {
+    await util.promisify(exec)(command);
+  }catch (error:any) {
+    if (error.stderr) {
+      throw new MissingRequirementError(toolName);
+    }
+  }
+}
+
+type ExecuteCommandResult = {
+  stdout: string;
+  stderr: string;
+};
+
+type ExecuteCommandByPlatformInput = {
+  [key in RunningPlatform]: string;
+};
+
+export async function executeCommand(
+  cmdsByPlatform: ExecuteCommandByPlatformInput,
+  toolName?: string,
+): Promise<ExecuteCommandResult> {
+  const runningPlatform = getPlatform();
+  const command = cmdsByPlatform[runningPlatform];
+  try {
+    return await util.promisify(exec)(command);
+  } catch (error: any) {
+    throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
+  }
+}
+
+function getPlatform(): RunningPlatform {
+  const currentPlatform = process.platform as RunningPlatform;
+  if (!AVAILABLE_PLATFORMS.includes(currentPlatform)) {
+    throw new Error(`Unsupported platform: ${currentPlatform}.`);
+  }
+  return currentPlatform;
+}
+
+export function openUrl(url: string): Promise<ChildProcess> {
+  return open(url);
+}
+
+export async function getVersion(toolName: string): Promise<string> {
+  try {
+    const toolResponse = await util.promisify(exec)(`${toolName} --version`);
+
+    if (toolResponse.stderr) {
+      throw new Error(toolResponse.stderr);
+    }
+
+    try {
+      const versionMatch = toolResponse.stdout.match(/(\d+\.\d+\.\d+)/);
+      if (versionMatch) {
+        return versionMatch[1];
+      }
+    } catch (err) {
+      throw new Error(`Could not parse ${toolName} version.`);
+    }
+  } catch (error) {
+    throw new Error(`Error getting ${toolName} version.`);
+  }
+
+  return "";
+}

package/src/lib/config/ConfigFileManager.ts

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

package/src/lib/config/KeychainManager.ts

@@ -0,0 +1,89 @@
+type Keytar = typeof import('keytar').default;
+
+let keytarModule: Keytar | null = null;
+let keytarLoadAttempted = false;
+
+async function getKeytar(): Promise<Keytar | null> {
+  if (keytarLoadAttempted) return keytarModule;
+  keytarLoadAttempted = true;
+  try {
+    const mod = await import('keytar');
+    keytarModule = mod.default ?? mod;
+    return keytarModule;
+  } catch {
+    return null;
+  }
+}
+
+export class KeychainManager {
+  private static readonly SERVICE = 'genlayer-cli';
+
+  constructor() {}
+
+  private getKeychainAccount(accountName: string): string {
+    return `account:${accountName}`;
+  }
+
+  async isKeychainAvailable(): Promise<boolean> {
+    try {
+      const keytar = await getKeytar();
+      if (!keytar) return false;
+      await keytar.findCredentials('test-service');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async storePrivateKey(accountName: string, privateKey: string): Promise<void> {
+    const keytar = await getKeytar();
+    if (!keytar) throw new Error('Keychain not available. Install libsecret-1-dev on Linux.');
+    try {
+      return await keytar.setPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName), privateKey);
+    } catch (error: any) {
+      if (error?.message?.includes('org.freedesktop.secrets')) {
+        throw new Error('Keychain service not running. Install and start gnome-keyring or another secrets service.');
+      }
+      throw error;
+    }
+  }
+
+  async getPrivateKey(accountName: string): Promise<string | null> {
+    const keytar = await getKeytar();
+    if (!keytar) return null;
+    try {
+      return await keytar.getPassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    } catch {
+      return null;
+    }
+  }
+
+  async removePrivateKey(accountName: string): Promise<boolean> {
+    const keytar = await getKeytar();
+    if (!keytar) return false;
+    try {
+      return await keytar.deletePassword(KeychainManager.SERVICE, this.getKeychainAccount(accountName));
+    } catch {
+      return false;
+    }
+  }
+
+  async listUnlockedAccounts(): Promise<string[]> {
+    const keytar = await getKeytar();
+    if (!keytar) return [];
+    try {
+      const credentials = await keytar.findCredentials(KeychainManager.SERVICE);
+      return credentials
+        .map(c => c.account)
+        .filter(a => a.startsWith('account:'))
+        .map(a => a.replace('account:', ''));
+    } catch {
+      return [];
+    }
+  }
+
+  async isAccountUnlocked(accountName: string): Promise<boolean> {
+    const key = await this.getPrivateKey(accountName);
+    return key !== null;
+  }
+}