genlayer 0.30.0 → 0.32.0

package/src/commands/account/send.ts

@@ -0,0 +1,150 @@
+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";
+import {KeystoreData} from "../../lib/interfaces/KeystoreData";
+
+export interface SendOptions {
+  to: string;
+  amount: string;
+  rpc?: string;
+  network?: 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 {
+      const keypairPath = this.getConfigByKey("keyPairPath");
+
+      if (!keypairPath || !existsSync(keypairPath)) {
+        this.failSpinner("No account found. Run 'genlayer account create' first.");
+        return;
+      }
+
+      const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+
+      if (!this.isValidKeystoreFormat(keystoreData)) {
+        this.failSpinner("Invalid keystore format.");
+        return;
+      }
+
+      // Get private key
+      const cachedKey = await this.keychainManager.getPrivateKey();
+      let privateKey: string;
+
+      if (cachedKey) {
+        privateKey = cachedKey;
+      } else {
+        this.stopSpinner();
+        const password = await this.promptPassword("Enter password to unlock account:");
+        this.startSpinner("Preparing transfer...");
+        const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, 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

@@ -0,0 +1,60 @@
+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";
+import {KeystoreData} from "../../lib/interfaces/KeystoreData";
+
+export class ShowAccountAction extends BaseAction {
+  constructor() {
+    super();
+  }
+
+  private getNetwork(): GenLayerChain {
+    return resolveNetwork(this.getConfig().network);
+  }
+
+  async execute(): Promise<void> {
+    this.startSpinner("Fetching account info...");
+
+    try {
+      const keypairPath = this.getConfigByKey("keyPairPath");
+
+      if (!keypairPath || !existsSync(keypairPath)) {
+        this.failSpinner("No account found. Run 'genlayer account create' first.");
+        return;
+      }
+
+      const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+
+      if (!this.isValidKeystoreFormat(keystoreData)) {
+        this.failSpinner("Invalid keystore format.");
+        return;
+      }
+
+      const address = keystoreData.address as Address;
+      const network = this.getNetwork();
+
+      const client = createClient({
+        chain: network,
+        account: address,
+      });
+
+      const balance = await client.getBalance({address});
+      const formattedBalance = formatEther(balance);
+
+      const isUnlocked = await this.keychainManager.getPrivateKey();
+
+      const result = {
+        address,
+        balance: `${formattedBalance} GEN`,
+        network: network.name || "localnet",
+        status: isUnlocked ? "unlocked" : "locked",
+      };
+
+      this.succeedSpinner("Account info", result);
+    } catch (error: any) {
+      this.failSpinner("Failed to get account info", error.message || error);
+    }
+  }
+}

package/src/commands/{keygen → account}/unlock.ts

@@ -1,8 +1,8 @@
-import { BaseAction } from "../../lib/actions/BaseAction";
-import { readFileSync, existsSync } from "fs";
-import { ethers } from "ethers";
+import {BaseAction} from "../../lib/actions/BaseAction";
+import {readFileSync, existsSync} from "fs";
+import {ethers} from "ethers";
 
-export class UnlockAction extends BaseAction {
+export class UnlockAccountAction extends BaseAction {
   async execute(): Promise<void> {
     this.startSpinner("Checking keychain availability...");
 
@@ -12,30 +12,30 @@ export class UnlockAction extends BaseAction {
       return;
     }
 
-    this.setSpinnerText("Checking for existing keystore...");
+    this.setSpinnerText("Checking for existing account...");
 
     const keypairPath = this.getConfigByKey("keyPairPath");
     if (!keypairPath || !existsSync(keypairPath)) {
-      this.failSpinner("No keystore file found. Please create a keypair first using 'genlayer keygen create'.");
+      this.failSpinner("No account found. Run 'genlayer account create' first.");
       return;
     }
 
     const keystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
     if (!this.isValidKeystoreFormat(keystoreData)) {
-      this.failSpinner("Invalid keystore format. Expected encrypted keystore file.");
+      this.failSpinner("Invalid keystore format.");
       return;
     }
 
     this.stopSpinner();
 
     try {
-      const password = await this.promptPassword("Enter password to decrypt keystore:");
+      const password = await this.promptPassword("Enter password to unlock account:");
       const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
-      
+
       await this.keychainManager.storePrivateKey(wallet.privateKey);
-      this.succeedSpinner("Wallet unlocked successfully! Your private key is now stored securely in the OS keychain.");
+      this.succeedSpinner("Account unlocked! Private key cached in OS keychain.");
     } catch (error) {
-      this.failSpinner("Failed to unlock wallet.", error);
+      this.failSpinner("Failed to unlock account.", error);
     }
   }
-} 
+}

package/src/commands/contracts/code.ts

@@ -0,0 +1,33 @@
+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/index.ts

@@ -3,6 +3,7 @@ import {DeployAction, DeployOptions, DeployScriptsOptions} from "./deploy";
 import {CallAction, CallOptions} from "./call";
 import {WriteAction, WriteOptions} from "./write";
 import {SchemaAction, SchemaOptions} from "./schema";
+import {CodeAction, CodeOptions} from "./code";
 
 function parseArg(value: string, previous: any[] = []): any[] {
   if (value === "true") return [...previous, true];
@@ -72,5 +73,14 @@ export function initializeContractsCommands(program: Command) {
       await schemaAction.schema({contractAddress, ...options});
     });
 
+  program
+    .command("code <contractAddress>")
+    .description("Get the source for a deployed contract")
+    .option("--rpc <rpcUrl>", "RPC URL for the network")
+    .action(async (contractAddress: string, options: CodeOptions) => {
+      const codeAction = new CodeAction();
+      await codeAction.code({contractAddress, ...options});
+    });
+
   return program;
 }

package/src/commands/network/setNetwork.ts

@@ -38,7 +38,7 @@ export class NetworkActions extends BaseAction {
         this.failSpinner(`Network ${networkName} not found`);
         return;
       }
-      this.writeConfig("network", JSON.stringify(selectedNetwork.value));
+      this.writeConfig("network", selectedNetwork.alias);
       this.succeedSpinner(`Network successfully set to ${selectedNetwork.name}`);
       return;
     }
@@ -48,13 +48,14 @@ export class NetworkActions extends BaseAction {
         type: "list",
         name: "selectedNetwork",
         message: "Select which network do you want to use:",
-        choices: networks,
+        choices: networks.map(n => ({name: n.name, value: n.alias})),
       },
     ];
     const networkAnswer = await inquirer.prompt(networkQuestions);
-    const selectedNetwork = networkAnswer.selectedNetwork;
+    const selectedAlias = networkAnswer.selectedNetwork;
+    const selectedNetwork = networks.find(n => n.alias === selectedAlias)!;
 
-    this.writeConfig("network", JSON.stringify(selectedNetwork));
+    this.writeConfig("network", selectedAlias);
     this.succeedSpinner(`Network successfully set to ${selectedNetwork.name}`);
   }
 }

package/src/commands/staking/StakingAction.ts

@@ -0,0 +1,125 @@
+import {BaseAction, BUILT_IN_NETWORKS, resolveNetwork} from "../../lib/actions/BaseAction";
+import {createClient, createAccount, formatStakingAmount, parseStakingAmount, abi} from "genlayer-js";
+import type {GenLayerClient, GenLayerChain, Address} from "genlayer-js/types";
+import {readFileSync, existsSync} from "fs";
+import {ethers} from "ethers";
+import {KeystoreData} from "../../lib/interfaces/KeystoreData";
+
+export interface StakingConfig {
+  rpc?: string;
+  stakingAddress?: string;
+  network?: string;
+}
+
+export class StakingAction extends BaseAction {
+  private _stakingClient: GenLayerClient<GenLayerChain> | null = null;
+
+  constructor() {
+    super();
+  }
+
+  private getNetwork(config: StakingConfig): GenLayerChain {
+    // Priority: --network option > global config > localnet default
+    if (config.network) {
+      const network = BUILT_IN_NETWORKS[config.network];
+      if (!network) {
+        throw new Error(`Unknown network: ${config.network}. Available: ${Object.keys(BUILT_IN_NETWORKS).join(", ")}`);
+      }
+      return {...network};
+    }
+
+    return resolveNetwork(this.getConfig().network);
+  }
+
+  protected async getStakingClient(config: StakingConfig): Promise<GenLayerClient<GenLayerChain>> {
+    if (!this._stakingClient) {
+      const network = this.getNetwork(config);
+
+      // Override staking address if provided
+      if (config.stakingAddress) {
+        network.stakingContract = {
+          address: config.stakingAddress,
+          abi: abi.STAKING_ABI,
+        };
+      }
+
+      const privateKey = await this.getPrivateKeyForStaking();
+      const account = createAccount(privateKey as `0x${string}`);
+
+      this._stakingClient = createClient({
+        chain: network,
+        endpoint: config.rpc,
+        account,
+      });
+    }
+    return this._stakingClient;
+  }
+
+  protected async getReadOnlyStakingClient(config: StakingConfig): Promise<GenLayerClient<GenLayerChain>> {
+    const network = this.getNetwork(config);
+
+    if (config.stakingAddress) {
+      network.stakingContract = {
+        address: config.stakingAddress,
+        abi: abi.STAKING_ABI,
+      };
+    }
+
+    const keypairPath = this.getConfigByKey("keyPairPath");
+    if (!keypairPath || !existsSync(keypairPath)) {
+      throw new Error("No account found. Run 'genlayer account create' first.");
+    }
+
+    const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+
+    return createClient({
+      chain: network,
+      endpoint: config.rpc,
+      account: keystoreData.address as Address,
+    });
+  }
+
+  private async getPrivateKeyForStaking(): Promise<string> {
+    const keypairPath = this.getConfigByKey("keyPairPath");
+
+    if (!keypairPath || !existsSync(keypairPath)) {
+      throw new Error("No account found. Run 'genlayer account create' first.");
+    }
+
+    const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+
+    if (!this.isValidKeystoreFormat(keystoreData)) {
+      throw new Error("Invalid keystore format.");
+    }
+
+    const cachedKey = await this.keychainManager.getPrivateKey();
+    if (cachedKey) {
+      return cachedKey;
+    }
+
+    // Stop spinner before prompting for password
+    this.stopSpinner();
+    const password = await this.promptPassword("Enter password to unlock account:");
+    this.startSpinner("Continuing...");
+
+    const wallet = await ethers.Wallet.fromEncryptedJson(keystoreData.encrypted, password);
+    return wallet.privateKey;
+  }
+
+  protected parseAmount(amount: string): bigint {
+    return parseStakingAmount(amount);
+  }
+
+  protected formatAmount(amount: bigint): string {
+    return formatStakingAmount(amount);
+  }
+
+  protected async getSignerAddress(): Promise<Address> {
+    const keypairPath = this.getConfigByKey("keyPairPath");
+    if (!keypairPath || !existsSync(keypairPath)) {
+      throw new Error("Keypair file not found.");
+    }
+    const keystoreData: KeystoreData = JSON.parse(readFileSync(keypairPath, "utf-8"));
+    return keystoreData.address as Address;
+  }
+}

package/src/commands/staking/delegatorClaim.ts

@@ -0,0 +1,41 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+export interface DelegatorClaimOptions extends StakingConfig {
+  validator: string;
+  delegator?: string;
+}
+
+export class DelegatorClaimAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: DelegatorClaimOptions): Promise<void> {
+    this.startSpinner("Claiming delegator withdrawals...");
+
+    try {
+      const client = await this.getStakingClient(options);
+      const delegatorAddress = options.delegator || (await this.getSignerAddress());
+
+      this.setSpinnerText(`Claiming for delegator ${delegatorAddress} from validator ${options.validator}...`);
+
+      const result = await client.delegatorClaim({
+        validator: options.validator as Address,
+        delegator: delegatorAddress as Address,
+      });
+
+      const output = {
+        transactionHash: result.transactionHash,
+        delegator: delegatorAddress,
+        validator: options.validator,
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Claim successful!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to claim", error.message || error);
+    }
+  }
+}

package/src/commands/staking/delegatorExit.ts

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

package/src/commands/staking/delegatorJoin.ts

@@ -0,0 +1,42 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+export interface DelegatorJoinOptions extends StakingConfig {
+  validator: string;
+  amount: string;
+}
+
+export class DelegatorJoinAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: DelegatorJoinOptions): Promise<void> {
+    this.startSpinner("Joining as delegator...");
+
+    try {
+      const client = await this.getStakingClient(options);
+      const amount = this.parseAmount(options.amount);
+
+      this.setSpinnerText(`Delegating ${this.formatAmount(amount)} to validator ${options.validator}...`);
+
+      const result = await client.delegatorJoin({
+        validator: options.validator as Address,
+        amount,
+      });
+
+      const output = {
+        transactionHash: result.transactionHash,
+        validator: result.validator,
+        amount: result.amount,
+        delegator: result.delegator,
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Successfully joined as delegator!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to join as delegator", error.message || error);
+    }
+  }
+}