genlayer 0.38.8 → 0.38.10

package/src/commands/staking/validatorExit.ts

@@ -0,0 +1,63 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+import {abi} from "genlayer-js";
+
+export interface ValidatorExitOptions extends StakingConfig {
+  validator: string;
+  shares: string;
+}
+
+export class ValidatorExitAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorExitOptions): Promise<void> {
+    this.startSpinner("Initiating validator 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 validatorWallet = options.validator as Address;
+      const {walletClient, publicClient} = await this.getViemClients(options);
+
+      this.setSpinnerText(`Exiting validator ${validatorWallet} with ${shares} shares...`);
+
+      const hash = await walletClient.writeContract({
+        address: validatorWallet,
+        abi: abi.VALIDATOR_WALLET_ABI,
+        functionName: "validatorExit",
+        args: [shares],
+      });
+
+      const receipt = await publicClient.waitForTransactionReceipt({hash});
+
+      // Check epoch to determine note
+      const readClient = await this.getReadOnlyStakingClient(options);
+      const epochInfo = await readClient.getEpochInfo();
+      const isEpochZero = epochInfo.currentEpoch === 0n;
+
+      const output = {
+        transactionHash: receipt.transactionHash,
+        validator: validatorWallet,
+        sharesWithdrawn: shares.toString(),
+        blockNumber: receipt.blockNumber.toString(),
+        gasUsed: receipt.gasUsed.toString(),
+        note: isEpochZero
+          ? "Epoch 0: Withdrawal claimable immediately"
+          : "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/validatorHistory.ts

@@ -0,0 +1,300 @@
+import {StakingAction, StakingConfig, BUILT_IN_NETWORKS} from "./StakingAction";
+import type {Address, GenLayerChain} from "genlayer-js/types";
+import {createPublicClient, http} from "viem";
+import Table from "cli-table3";
+import chalk from "chalk";
+
+// Event ABIs for log fetching
+// v0.5: SlashedFromIdleness adds txStatus (uint8 enum) parameter
+const SLASH_EVENT_ABI = {
+  type: "event",
+  name: "SlashedFromIdleness",
+  inputs: [
+    {name: "validator", type: "address", indexed: true},
+    {name: "txId", type: "bytes32", indexed: false},
+    {name: "epoch", type: "uint256", indexed: false},
+    {name: "percentage", type: "uint256", indexed: false},
+    {name: "txStatus", type: "uint8", indexed: false},
+  ],
+} as const;
+
+const REWARD_EVENT_ABI = {
+  type: "event",
+  name: "ValidatorPrime",
+  inputs: [
+    {name: "validator", type: "address", indexed: false},
+    {name: "epoch", type: "uint256", indexed: false},
+    {name: "validatorRewards", type: "uint256", indexed: false},
+    {name: "delegatorRewards", type: "uint256", indexed: false},
+  ],
+} as const;
+
+export interface ValidatorHistoryOptions extends StakingConfig {
+  validator?: string;
+  fromBlock?: string;
+  fromEpoch?: string;
+  epochs?: string;
+  limit?: string;
+  all?: boolean;
+}
+
+interface SlashEvent {
+  type: "slash";
+  epoch: bigint;
+  txId: string;
+  percentage: bigint;
+  blockNumber: bigint;
+  timestamp: Date;
+}
+
+interface RewardEvent {
+  type: "reward";
+  epoch: bigint;
+  validatorRewards: bigint;
+  delegatorRewards: bigint;
+  blockNumber: bigint;
+  timestamp: Date;
+}
+
+type HistoryEvent = SlashEvent | RewardEvent;
+
+export class ValidatorHistoryAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  private getNetworkForHistory(config: StakingConfig): GenLayerChain {
+    if (config.network) {
+      const network = BUILT_IN_NETWORKS[config.network];
+      if (!network) {
+        throw new Error(`Unknown network: ${config.network}`);
+      }
+      return network;
+    }
+    // Check global config
+    const globalNetwork = this.getConfig().network;
+    if (globalNetwork && BUILT_IN_NETWORKS[globalNetwork]) {
+      return BUILT_IN_NETWORKS[globalNetwork];
+    }
+    return BUILT_IN_NETWORKS["localnet"];
+  }
+
+  async execute(options: ValidatorHistoryOptions): Promise<void> {
+    this.startSpinner("Fetching validator history...");
+
+    try {
+      // Check network - localnet doesn't support eth_getLogs
+      const chain = this.getNetworkForHistory(options);
+      if (chain.id === 808080) {
+        this.failSpinner("validator-history requires testnet-asimov (localnet doesn't support event logs)");
+        return;
+      }
+
+      const client = await this.getReadOnlyStakingClient(options);
+      const validatorAddress = options.validator || (await this.getSignerAddress());
+
+      // Verify it's a validator
+      const isValidator = await client.isValidator(validatorAddress as Address);
+      if (!isValidator) {
+        this.failSpinner(`Address ${validatorAddress} is not a validator`);
+        return;
+      }
+
+      this.setSpinnerText("Fetching contract addresses...");
+
+      // Get addresses
+      const stakingAddress = client.getStakingContract().address;
+      const slashingAddress = await client.getSlashingAddress();
+
+      // Create public client for log fetching
+      const publicClient = createPublicClient({
+        chain,
+        transport: http(chain.rpcUrls.default.http[0]),
+      });
+
+      // Determine epoch range for filtering
+      const epochInfo = await client.getEpochInfo();
+      const currentEpoch = epochInfo.currentEpoch;
+      const defaultEpochs = 10n;
+
+      let minEpoch: bigint | null = null;
+      let fromBlock: bigint | "earliest" = "earliest";
+
+      if (options.fromBlock) {
+        // Explicit block takes precedence
+        fromBlock = BigInt(options.fromBlock);
+      } else if (options.fromEpoch) {
+        // Filter by starting epoch
+        minEpoch = BigInt(options.fromEpoch);
+      } else if (options.all) {
+        // Fetch all history (warn user)
+        console.log(chalk.yellow("Warning: Fetching all history from genesis. This may be slow for long-lived validators."));
+        console.log(chalk.yellow("Consider using --epochs <n> or --from-epoch <n> for faster queries.\n"));
+      } else {
+        // Default: last N epochs
+        const numEpochs = options.epochs ? BigInt(options.epochs) : defaultEpochs;
+        minEpoch = currentEpoch > numEpochs ? currentEpoch - numEpochs : 0n;
+      }
+
+      const limit = options.limit ? parseInt(options.limit) : 50;
+
+      this.setSpinnerText("Fetching slash events...");
+
+      // Fetch slash events (indexed by validator)
+      const slashLogs = await publicClient.getLogs({
+        address: slashingAddress as `0x${string}`,
+        event: SLASH_EVENT_ABI,
+        args: {validator: validatorAddress as `0x${string}`},
+        fromBlock,
+        toBlock: "latest",
+      });
+
+      this.setSpinnerText("Fetching reward events...");
+
+      // Fetch reward events (not indexed, need to filter client-side)
+      const rewardLogs = await publicClient.getLogs({
+        address: stakingAddress,
+        event: REWARD_EVENT_ABI,
+        fromBlock,
+        toBlock: "latest",
+      });
+
+      // Filter rewards to this validator
+      const filteredRewardLogs = rewardLogs.filter(
+        log => (log.args as any).validator?.toLowerCase() === validatorAddress.toLowerCase()
+      );
+
+      // Get unique block numbers to fetch timestamps
+      const allLogs = [...slashLogs, ...filteredRewardLogs];
+      const uniqueBlocks = [...new Set(allLogs.map(l => l.blockNumber))];
+
+      this.setSpinnerText("Fetching block timestamps...");
+
+      // Fetch block timestamps in batches
+      const blockTimestamps = new Map<bigint, Date>();
+      const BATCH_SIZE = 10;
+      for (let i = 0; i < uniqueBlocks.length; i += BATCH_SIZE) {
+        const batch = uniqueBlocks.slice(i, i + BATCH_SIZE);
+        const blocks = await Promise.all(
+          batch.map(blockNumber => publicClient.getBlock({blockNumber}))
+        );
+        blocks.forEach(block => {
+          blockTimestamps.set(block.number, new Date(Number(block.timestamp) * 1000));
+        });
+      }
+
+      // Transform to typed events
+      let slashEvents: SlashEvent[] = slashLogs.map(log => ({
+        type: "slash" as const,
+        epoch: (log.args as any).epoch as bigint,
+        txId: (log.args as any).txId as string,
+        percentage: (log.args as any).percentage as bigint,
+        blockNumber: log.blockNumber,
+        timestamp: blockTimestamps.get(log.blockNumber) || new Date(0),
+      }));
+
+      let rewardEvents: RewardEvent[] = filteredRewardLogs.map(log => ({
+        type: "reward" as const,
+        epoch: (log.args as any).epoch as bigint,
+        validatorRewards: (log.args as any).validatorRewards as bigint,
+        delegatorRewards: (log.args as any).delegatorRewards as bigint,
+        blockNumber: log.blockNumber,
+        timestamp: blockTimestamps.get(log.blockNumber) || new Date(0),
+      }));
+
+      // Filter by epoch if specified
+      if (minEpoch !== null) {
+        slashEvents = slashEvents.filter(e => e.epoch >= minEpoch!);
+        rewardEvents = rewardEvents.filter(e => e.epoch >= minEpoch!);
+      }
+
+      // Combine and sort by block number descending
+      const allEvents: HistoryEvent[] = [...slashEvents, ...rewardEvents];
+      allEvents.sort((a, b) => Number(b.blockNumber - a.blockNumber));
+
+      // Apply limit
+      const limitedEvents = allEvents.slice(0, limit);
+
+      // Calculate totals
+      const totalValidatorRewards = rewardEvents.reduce((sum, e) => sum + e.validatorRewards, 0n);
+      const totalDelegatorRewards = rewardEvents.reduce((sum, e) => sum + e.delegatorRewards, 0n);
+
+      this.stopSpinner();
+
+      // Display results
+      if (limitedEvents.length === 0) {
+        console.log(chalk.yellow("\nNo history events found for this validator.\n"));
+        return;
+      }
+
+      // Format timestamp as datetime
+      const formatTime = (date: Date): string => {
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const hours = String(date.getHours()).padStart(2, "0");
+        const minutes = String(date.getMinutes()).padStart(2, "0");
+        return `${month}-${day} ${hours}:${minutes}`;
+      };
+
+      // Create table
+      const table = new Table({
+        head: [
+          chalk.cyan("Time"),
+          chalk.cyan("Epoch"),
+          chalk.cyan("Type"),
+          chalk.cyan("Details"),
+          chalk.cyan("GL TxId / Block"),
+        ],
+        style: {head: [], border: []},
+      });
+
+      for (const event of limitedEvents) {
+        if (event.type === "slash") {
+          const pct = Number(event.percentage) / 100; // basis points to %
+          table.push([
+            formatTime(event.timestamp),
+            event.epoch.toString(),
+            chalk.red("SLASH"),
+            `${pct.toFixed(2)}%`,
+            event.txId,
+          ]);
+        } else {
+          const valReward = client.formatStakingAmount(event.validatorRewards);
+          const delReward = client.formatStakingAmount(event.delegatorRewards);
+          table.push([
+            formatTime(event.timestamp),
+            event.epoch.toString(),
+            chalk.green("REWARD"),
+            `Val: ${valReward}, Del: ${delReward}`,
+            `block ${event.blockNumber}`,
+          ]);
+        }
+      }
+
+      console.log("");
+      console.log(chalk.bold(`History for ${validatorAddress}`));
+      console.log(table.toString());
+      console.log("");
+
+      // Summary
+      const epochRangeInfo = minEpoch !== null
+        ? `epochs ${minEpoch}-${currentEpoch}`
+        : options.fromBlock
+          ? `from block ${options.fromBlock}`
+          : "all epochs";
+      console.log(chalk.gray("Summary:"));
+      console.log(chalk.gray(`  Range: ${epochRangeInfo}`));
+      console.log(chalk.gray(`  Slash events: ${slashEvents.length}`));
+      console.log(chalk.gray(`  Reward events: ${rewardEvents.length}`));
+      console.log(chalk.gray(`  Total validator rewards: ${client.formatStakingAmount(totalValidatorRewards)}`));
+      console.log(chalk.gray(`  Total delegator rewards: ${client.formatStakingAmount(totalDelegatorRewards)}`));
+      if (allEvents.length > limit) {
+        console.log(chalk.gray(`  (showing ${limit} of ${allEvents.length} events)`));
+      }
+      console.log(chalk.gray(`  Use --all to fetch complete history, --epochs <n> for last N epochs`));
+      console.log("");
+    } catch (error: any) {
+      this.failSpinner("Failed to get validator history", error.message || error);
+    }
+  }
+}

package/src/commands/staking/validatorJoin.ts

@@ -0,0 +1,47 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+export interface ValidatorJoinOptions extends StakingConfig {
+  amount: string;
+  operator?: string;
+}
+
+export class ValidatorJoinAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorJoinOptions): Promise<void> {
+    this.startSpinner("Creating a new validator...");
+
+    try {
+      const client = await this.getStakingClient(options);
+      const amount = this.parseAmount(options.amount);
+      const signerAddress = await this.getSignerAddress();
+
+      this.setSpinnerText(`Creating validator with ${this.formatAmount(amount)} stake...`);
+      this.log(`  From: ${signerAddress}`);
+      if (options.operator) {
+        this.log(`  Operator: ${options.operator}`);
+      }
+
+      const result = await client.validatorJoin({
+        amount,
+        operator: options.operator as Address | undefined,
+      });
+
+      const output = {
+        transactionHash: result.transactionHash,
+        validatorWallet: result.validatorWallet,
+        amount: result.amount,
+        operator: result.operator,
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Validator created successfully!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to create validator", error.message || error);
+    }
+  }
+}

package/src/commands/staking/validatorPrime.ts

@@ -0,0 +1,73 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+import chalk from "chalk";
+
+export interface ValidatorPrimeOptions extends StakingConfig {
+  validator: string;
+}
+
+export class ValidatorPrimeAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorPrimeOptions): Promise<void> {
+    this.startSpinner("Priming validator...");
+
+    try {
+      const client = await this.getStakingClient(options);
+
+      this.setSpinnerText(`Priming validator ${options.validator}...`);
+
+      const result = await client.validatorPrime({validator: options.validator as Address});
+
+      const output = {
+        transactionHash: result.transactionHash,
+        validator: options.validator,
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Validator primed for next epoch!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to prime validator", error.message || error);
+    }
+  }
+
+  async primeAll(options: StakingConfig): Promise<void> {
+    this.startSpinner("Fetching validators...");
+
+    try {
+      const client = await this.getStakingClient(options);
+
+      // Get all validators from tree
+      this.setSpinnerText("Fetching validators...");
+      const allValidators = await this.getAllValidatorsFromTree(options);
+
+      this.stopSpinner();
+      console.log(`\nPriming ${allValidators.length} validators:\n`);
+
+      let succeeded = 0;
+      let skipped = 0;
+
+      for (const addr of allValidators) {
+        process.stdout.write(`  ${addr} ... `);
+
+        try {
+          const result = await client.validatorPrime({validator: addr});
+          console.log(chalk.green(`primed ${result.transactionHash}`));
+          succeeded++;
+        } catch (error: any) {
+          const msg = error.message || String(error);
+          const shortErr = msg.length > 60 ? msg.slice(0, 57) + "..." : msg;
+          console.log(chalk.gray(`skipped: ${shortErr}`));
+          skipped++;
+        }
+      }
+
+      console.log(`\n${chalk.green(`${succeeded} primed`)}, ${chalk.gray(`${skipped} skipped`)}\n`);
+    } catch (error: any) {
+      this.failSpinner("Failed to prime validators", error.message || error);
+    }
+  }
+}