genlayer 0.34.0 → 0.34.3

package/src/commands/account/send.ts

@@ -1,162 +0,0 @@
-import {BaseAction, BUILT_IN_NETWORKS, resolveNetwork} from "../../lib/actions/BaseAction";
-import {parseEther, formatEther} from "viem";
-import {createClient, createAccount} from "genlayer-js";
-import type {GenLayerChain, Address, Hash} from "genlayer-js/types";
-import {readFileSync, existsSync} from "fs";
-import {ethers} from "ethers";
-
-export interface SendOptions {
-  to: string;
-  amount: string;
-  rpc?: string;
-  network?: string;
-  account?: string;
-  password?: string;
-}
-
-export class SendAction extends BaseAction {
-  constructor() {
-    super();
-  }
-
-  private getNetwork(networkOption?: string): GenLayerChain {
-    if (networkOption) {
-      const network = BUILT_IN_NETWORKS[networkOption];
-      if (!network) {
-        throw new Error(`Unknown network: ${networkOption}. Available: ${Object.keys(BUILT_IN_NETWORKS).join(", ")}`);
-      }
-      return network;
-    }
-    return resolveNetwork(this.getConfig().network);
-  }
-
-  private parseAmount(amount: string): bigint {
-    // Support "10gen" or "10" (assumes gen) or wei values
-    const lowerAmount = amount.toLowerCase();
-    if (lowerAmount.endsWith("gen")) {
-      const value = lowerAmount.slice(0, -3);
-      return parseEther(value);
-    }
-    // If it's a large number (likely wei), use as-is
-    if (BigInt(amount) > 1_000_000_000_000n) {
-      return BigInt(amount);
-    }
-    // Otherwise assume it's in GEN
-    return parseEther(amount);
-  }
-
-  async execute(options: SendOptions): Promise<void> {
-    this.startSpinner("Preparing transfer...");
-
-    try {
-      if (options.account) {
-        this.accountOverride = options.account;
-      }
-
-      const accountName = this.resolveAccountName();
-      const keystorePath = this.getKeystorePath(accountName);
-
-      if (!existsSync(keystorePath)) {
-        this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
-        return;
-      }
-
-      const keystoreJson = readFileSync(keystorePath, "utf-8");
-      const keystoreData = JSON.parse(keystoreJson);
-
-      if (!this.isValidKeystoreFormat(keystoreData)) {
-        this.failSpinner("Invalid keystore format.");
-        return;
-      }
-
-      // Get private key
-      const cachedKey = await this.keychainManager.getPrivateKey(accountName);
-      let privateKey: string;
-
-      if (cachedKey) {
-        privateKey = cachedKey;
-      } else {
-        let password: string;
-        if (options.password) {
-          password = options.password;
-        } else {
-          this.stopSpinner();
-          password = await this.promptPassword(`Enter password to unlock account '${accountName}':`);
-          this.startSpinner("Preparing transfer...");
-        }
-        const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
-        privateKey = wallet.privateKey;
-      }
-
-      const network = this.getNetwork(options.network);
-      const account = createAccount(privateKey as Hash);
-      const amount = this.parseAmount(options.amount);
-
-      const client = createClient({
-        chain: network,
-        account,
-        endpoint: options.rpc,
-      });
-
-      this.setSpinnerText(`Sending ${formatEther(amount)} GEN to ${options.to}...`);
-
-      // Get nonce
-      const nonce = await client.getCurrentNonce({address: account.address});
-
-      // Prepare and sign transaction (let prepareTransactionRequest estimate gas)
-      const transactionRequest = await client.prepareTransactionRequest({
-        account,
-        to: options.to as Address,
-        value: amount,
-        type: "legacy",
-        nonce: Number(nonce),
-      });
-
-      const serializedTransaction = await account.signTransaction(transactionRequest);
-      const txHash = await client.sendRawTransaction({serializedTransaction});
-
-      this.setSpinnerText(`Transaction submitted: ${txHash}\nWaiting for confirmation...`);
-
-      // Poll for receipt (standard ETH transfer, not GenVM tx)
-      let receipt = null;
-      for (let i = 0; i < 60; i++) {
-        try {
-          receipt = await client.getTransactionReceipt({hash: txHash});
-          if (receipt) break;
-        } catch {
-          // Receipt not available yet, continue polling
-        }
-        await new Promise((r) => setTimeout(r, 2000));
-      }
-
-      if (!receipt) {
-        // Tx submitted but receipt not found yet - still success
-        this.succeedSpinner("Transfer submitted (pending confirmation)", {
-          transactionHash: txHash,
-          from: account.address,
-          to: options.to,
-          amount: `${formatEther(amount)} GEN`,
-        });
-        return;
-      }
-
-      if (receipt.status === "reverted") {
-        this.failSpinner("Transaction reverted");
-        return;
-      }
-
-      const result = {
-        transactionHash: txHash,
-        from: account.address,
-        to: options.to,
-        amount: `${formatEther(amount)} GEN`,
-        blockNumber: receipt.blockNumber.toString(),
-        gasUsed: receipt.gasUsed.toString(),
-      };
-
-      this.succeedSpinner("Transfer successful!", result);
-    } catch (error: any) {
-      this.failSpinner("Transfer failed", error.message || error);
-    }
-  }
-}

package/src/commands/account/show.ts

@@ -1,74 +0,0 @@
-import {BaseAction, resolveNetwork} from "../../lib/actions/BaseAction";
-import {formatEther} from "viem";
-import {createClient} from "genlayer-js";
-import type {GenLayerChain, Address} from "genlayer-js/types";
-import {readFileSync, existsSync} from "fs";
-
-export interface ShowAccountOptions {
-  rpc?: string;
-  account?: string;
-}
-
-export class ShowAccountAction extends BaseAction {
-  constructor() {
-    super();
-  }
-
-  private getNetwork(): GenLayerChain {
-    return resolveNetwork(this.getConfig().network);
-  }
-
-  async execute(options?: ShowAccountOptions): Promise<void> {
-    this.startSpinner("Fetching account info...");
-
-    try {
-      if (options?.account) {
-        this.accountOverride = options.account;
-      }
-
-      const accountName = this.resolveAccountName();
-      const keystorePath = this.getKeystorePath(accountName);
-
-      if (!existsSync(keystorePath)) {
-        this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
-        return;
-      }
-
-      const keystoreData = JSON.parse(readFileSync(keystorePath, "utf-8"));
-
-      if (!this.isValidKeystoreFormat(keystoreData)) {
-        this.failSpinner("Invalid keystore format.");
-        return;
-      }
-
-      const rawAddr = keystoreData.address;
-      const address = (rawAddr.startsWith("0x") ? rawAddr : `0x${rawAddr}`) as Address;
-      const network = this.getNetwork();
-
-      const client = createClient({
-        chain: network,
-        account: address,
-        endpoint: options?.rpc,
-      });
-
-      const balance = await client.getBalance({address});
-      const formattedBalance = formatEther(balance);
-
-      const isUnlocked = await this.keychainManager.isAccountUnlocked(accountName);
-      const isActive = this.getActiveAccount() === accountName;
-
-      const result = {
-        name: accountName,
-        address,
-        balance: `${formattedBalance} GEN`,
-        network: network.name || "localnet",
-        status: isUnlocked ? "unlocked" : "locked",
-        active: isActive,
-      };
-
-      this.succeedSpinner("Account info", result);
-    } catch (error: any) {
-      this.failSpinner("Failed to get account info", error.message || error);
-    }
-  }
-}

package/src/commands/account/unlock.ts

@@ -1,56 +0,0 @@
-import {BaseAction} from "../../lib/actions/BaseAction";
-import {readFileSync, existsSync} from "fs";
-import {ethers} from "ethers";
-
-export interface UnlockAccountOptions {
-  account?: string;
-  password?: string;
-}
-
-export class UnlockAccountAction extends BaseAction {
-  async execute(options?: UnlockAccountOptions): Promise<void> {
-    this.startSpinner("Checking keychain availability...");
-
-    const keychainAvailable = await this.keychainManager.isKeychainAvailable();
-    if (!keychainAvailable) {
-      this.failSpinner("OS keychain is not available. This command requires a supported keychain (e.g. macOS Keychain, Windows Credential Manager, or GNOME Keyring).");
-      return;
-    }
-
-    if (options?.account) {
-      this.accountOverride = options.account;
-    }
-
-    const accountName = this.resolveAccountName();
-    this.setSpinnerText(`Checking for account '${accountName}'...`);
-
-    const keystorePath = this.getKeystorePath(accountName);
-    if (!existsSync(keystorePath)) {
-      this.failSpinner(`Account '${accountName}' not found. Run 'genlayer account create --name ${accountName}' first.`);
-      return;
-    }
-
-    const keystoreJson = readFileSync(keystorePath, "utf-8");
-    const keystoreData = JSON.parse(keystoreJson);
-    if (!this.isValidKeystoreFormat(keystoreData)) {
-      this.failSpinner("Invalid keystore format.");
-      return;
-    }
-
-    try {
-      let password: string;
-      if (options?.password) {
-        password = options.password;
-      } else {
-        this.stopSpinner();
-        password = await this.promptPassword(`Enter password to unlock '${accountName}':`);
-      }
-      const wallet = await ethers.Wallet.fromEncryptedJson(keystoreJson, password);
-
-      await this.keychainManager.storePrivateKey(accountName, wallet.privateKey);
-      this.succeedSpinner(`Account '${accountName}' unlocked! Private key cached in OS keychain.`);
-    } catch (error) {
-      this.failSpinner("Failed to unlock account.", error);
-    }
-  }
-}

package/src/commands/account/use.ts

@@ -1,21 +0,0 @@
-import {BaseAction} from "../../lib/actions/BaseAction";
-
-export class UseAccountAction extends BaseAction {
-  constructor() {
-    super();
-  }
-
-  async execute(name: string): Promise<void> {
-    try {
-      if (!this.accountExists(name)) {
-        this.failSpinner(`Account '${name}' does not exist. Run 'genlayer account list' to see available accounts.`);
-        return;
-      }
-
-      this.setActiveAccount(name);
-      this.logSuccess(`Active account set to '${name}'`);
-    } catch (error) {
-      this.failSpinner("Failed to set active account", error);
-    }
-  }
-}

package/src/commands/config/getSetReset.ts

@@ -1,51 +0,0 @@
-import { BaseAction } from "../../lib/actions/BaseAction";
-
-export class ConfigActions extends BaseAction {
-
-  constructor() {
-    super();
-  }
-
-  set(keyValue: string): void {
-    const [key, value] = keyValue.split("=");
-    this.startSpinner(`Updating configuration: ${key}`);
-
-    if (!key || value === undefined) {
-      this.failSpinner("Invalid format. Use 'key=value'.");
-      return;
-    }
-
-    this.writeConfig(key, value);
-    this.succeedSpinner(`Configuration successfully updated`);
-  }
-
-  get(key?: string): void {
-    this.startSpinner(key ? `Retrieving value for: ${key}` : "Retrieving all configurations");
-
-    if (key) {
-      const value = this.getConfigByKey(key);
-      if (value === null) {
-        this.failSpinner(`No configuration found for '${key}'.`);
-      } else {
-        this.succeedSpinner(`Configuration successfully retrieved`, `${key}=${value}`);
-      }
-    } else {
-      const config = this.getConfig();
-      this.succeedSpinner("All configurations successfully retrieved", JSON.stringify(config, null, 2));
-    }
-  }
-
-  reset(key: string): void {
-    this.startSpinner(`Resetting configuration: ${key}`);
-
-    const config = this.getConfig();
-    if (!(key in config)) {
-      this.failSpinner(`Configuration key '${key}' does not exist.`);
-      return;
-    }
-
-    delete config[key];
-    this.writeConfig(key, undefined);
-    this.succeedSpinner(`Configuration successfully reset`);
-  }
-}

package/src/commands/config/index.ts

@@ -1,30 +0,0 @@
-import { Command } from "commander";
-import { ConfigActions } from "./getSetReset";
-
-export function initializeConfigCommands(program: Command) {
-  const configActions = new ConfigActions();
-
-  const configCommand = program
-    .command("config")
-    .description("Manage CLI configuration, including the default network");
-
-  configCommand
-    .command("set")
-    .description("Set a configuration value")
-    .argument("<key=value>", "Configuration key-value pair to set")
-    .action((keyValue: string) => configActions.set(keyValue));
-
-  configCommand
-    .command("get")
-    .description("Get the current configuration")
-    .argument("[key]", "Configuration key to retrieve")
-    .action((key?: string) => configActions.get(key));
-
-  configCommand
-    .command("reset")
-    .description("Reset a configuration value to its default")
-    .argument("<key>", "Configuration key to reset")
-    .action((key: string) => configActions.reset(key));
-
-  return program;
-}

package/src/commands/contracts/call.ts

@@ -1,39 +0,0 @@
-import {BaseAction} from "../../lib/actions/BaseAction";
-
-export interface CallOptions {
-  args: any[];
-  rpc?: string;
-}
-
-export class CallAction extends BaseAction {
-  constructor() {
-    super();
-  }
-
-  async call({
-    contractAddress,
-    method,
-    args,
-    rpc,
-  }: {
-    contractAddress: string;
-    method: string;
-    args: any[];
-    rpc?: string;
-  }): Promise<void> {
-    const client = await this.getClient(rpc, true);
-    await client.initializeConsensusSmartContract();
-    this.startSpinner(`Calling method ${method} on contract at ${contractAddress}...`);
-
-    try {
-      const result = await client.readContract({
-        address: contractAddress as any,
-        functionName: method,
-        args,
-      });
-      this.succeedSpinner("Read operation successfully executed", result);
-    } catch (error) {
-      this.failSpinner("Error during read operation", error);
-    }
-  }
-}

package/src/commands/contracts/code.ts

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

package/src/commands/contracts/deploy.ts

@@ -1,157 +0,0 @@
-import fs from "fs";
-import path from "path";
-import {BaseAction} from "../../lib/actions/BaseAction";
-import {pathToFileURL} from "url";
-import {TransactionStatus} from "genlayer-js/types";
-import {buildSync} from "esbuild";
-
-export interface DeployOptions {
-  contract?: string;
-  args?: any[];
-  rpc?: string;
-}
-
-export interface DeployScriptsOptions {
-  rpc?: string;
-}
-
-export class DeployAction extends BaseAction {
-  private readonly deployDir = path.resolve(process.cwd(), "deploy");
-
-  constructor() {
-    super();
-  }
-
-  private readContractCode(contractPath: string): string {
-    if (!fs.existsSync(contractPath)) {
-      throw new Error(`Contract file not found: ${contractPath}`);
-    }
-    return fs.readFileSync(contractPath, "utf-8");
-  }
-
-  private async executeTsScript(filePath: string, rpcUrl?: string): Promise<void> {
-    const outFile = filePath.replace(/\.ts$/, ".compiled.js");
-    this.startSpinner(`Transpiling TypeScript file: ${filePath}`);
-    try {
-      buildSync({
-        entryPoints: [filePath],
-        outfile: outFile,
-        bundle: false,
-        platform: "node",
-        format: "esm",
-        target: "es2020",
-        sourcemap: false,
-      });
-      await this.executeJsScript(filePath, outFile, rpcUrl);
-    } catch (error) {
-      this.failSpinner(`Error executing: ${filePath}`, error);
-    } finally {
-      fs.unlinkSync(outFile);
-    }
-  }
-
-  private async executeJsScript(
-    filePath: string,
-    transpiledFilePath?: string,
-    rpcUrl?: string,
-  ): Promise<void> {
-    this.startSpinner(`Executing file: ${filePath}`);
-    try {
-      const module = await import(pathToFileURL(transpiledFilePath || filePath).href);
-      if (!module.default || typeof module.default !== "function") {
-        this.failSpinner(`No "default" function found in: ${filePath}`);
-        return;
-      }
-      const client = await this.getClient(rpcUrl);
-      await module.default(client);
-      this.succeedSpinner(`Successfully executed: ${filePath}`);
-    } catch (error) {
-      this.failSpinner(`Error executing: ${filePath}`, error);
-    }
-  }
-
-  async deployScripts(options?: DeployScriptsOptions) {
-    this.startSpinner("Searching for deploy scripts...");
-    if (!fs.existsSync(this.deployDir)) {
-      this.failSpinner("No deploy folder found.");
-      return;
-    }
-    const files = fs
-      .readdirSync(this.deployDir)
-      .filter(file => file.endsWith(".ts") || file.endsWith(".js"))
-      .sort((a, b) => {
-        const numA = parseInt(a.split("_")[0]);
-        const numB = parseInt(b.split("_")[0]);
-
-        if (!isNaN(numA) && !isNaN(numB)) return numA - numB;
-        if (!isNaN(numA)) return -1;
-        if (!isNaN(numB)) return 1;
-        return a.localeCompare(b);
-      });
-
-    if (files.length === 0) {
-      this.failSpinner("No deploy scripts found.");
-      return;
-    }
-
-    this.setSpinnerText(`Found ${files.length} deploy scripts. Executing...`);
-
-    for (const file of files) {
-      const filePath = path.resolve(this.deployDir, file);
-      this.setSpinnerText(`Executing script: ${filePath}`);
-      try {
-        if (file.endsWith(".ts")) {
-          await this.executeTsScript(filePath, options?.rpc);
-        } else {
-          await this.executeJsScript(filePath, undefined, options?.rpc);
-        }
-      } catch (error) {
-        this.failSpinner(`Error executing script: ${filePath}`, error);
-      }
-    }
-  }
-
-  async deploy(options: DeployOptions): Promise<void> {
-    try {
-      const client = await this.getClient(options.rpc);
-      this.startSpinner("Setting up the deployment environment...");
-      await client.initializeConsensusSmartContract();
-
-      if (!options.contract) {
-        this.failSpinner("No contract specified for deployment.");
-        return;
-      }
-      this.setSpinnerText("Reading contract code...");
-      const contractCode = this.readContractCode(options.contract);
-
-      if (!contractCode) {
-        this.failSpinner("Contract code is empty.");
-        return;
-      }
-
-      const leaderOnly = false;
-      const deployParams: any = {code: contractCode, args: options.args, leaderOnly};
-
-      this.setSpinnerText("Starting contract deployment...");
-      this.log("Deployment Parameters:", deployParams);
-
-      const hash = (await client.deployContract(deployParams)) as any;
-      this.log("Deployment Transaction Hash:", hash);
-      const result = await client.waitForTransactionReceipt({
-        hash,
-        retries: 50,
-        interval: 5000,
-        status: TransactionStatus.ACCEPTED,
-      });
-
-      this.log("Deployment Receipt:", result);
-
-      this.succeedSpinner("Contract deployed successfully.", {
-        "Transaction Hash": hash,
-        "Contract Address": result.data?.contract_address,
-      });
-    } catch (error) {
-      this.failSpinner("Error deploying contract", error);
-    }
-  }
-}