genlayer 0.34.0 → 0.34.3

package/src/commands/staking/validatorExit.ts

@@ -1,63 +0,0 @@
-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

@@ -1,298 +0,0 @@
-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
-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},
-  ],
-} 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

@@ -1,47 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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);
-    }
-  }
-}