genlayer 0.31.0 → 0.32.1

package/src/commands/staking/setIdentity.ts

@@ -0,0 +1,66 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+export interface SetIdentityOptions extends StakingConfig {
+  validator: string;
+  moniker: string;
+  logoUri?: string;
+  website?: string;
+  description?: string;
+  email?: string;
+  twitter?: string;
+  telegram?: string;
+  github?: string;
+  extraCid?: string;
+}
+
+export class SetIdentityAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: SetIdentityOptions): Promise<void> {
+    this.startSpinner("Setting validator identity...");
+
+    try {
+      const client = await this.getStakingClient(options);
+
+      this.setSpinnerText(`Setting identity for ${options.validator}...`);
+
+      const result = await client.setIdentity({
+        validator: options.validator as Address,
+        moniker: options.moniker,
+        logoUri: options.logoUri,
+        website: options.website,
+        description: options.description,
+        email: options.email,
+        twitter: options.twitter,
+        telegram: options.telegram,
+        github: options.github,
+        extraCid: options.extraCid,
+      });
+
+      const output: Record<string, any> = {
+        transactionHash: result.transactionHash,
+        validator: options.validator,
+        moniker: options.moniker,
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      // Add optional fields that were set
+      if (options.logoUri) output.logoUri = options.logoUri;
+      if (options.website) output.website = options.website;
+      if (options.description) output.description = options.description;
+      if (options.email) output.email = options.email;
+      if (options.twitter) output.twitter = options.twitter;
+      if (options.telegram) output.telegram = options.telegram;
+      if (options.github) output.github = options.github;
+      if (options.extraCid) output.extraCid = options.extraCid;
+
+      this.succeedSpinner("Validator identity set!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to set identity", error.message || error);
+    }
+  }
+}

package/src/commands/staking/setOperator.ts

@@ -0,0 +1,40 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+export interface SetOperatorOptions extends StakingConfig {
+  validator: string;
+  operator: string;
+}
+
+export class SetOperatorAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: SetOperatorOptions): Promise<void> {
+    this.startSpinner("Setting operator...");
+
+    try {
+      const client = await this.getStakingClient(options);
+
+      this.setSpinnerText(`Setting operator to ${options.operator}...`);
+
+      const result = await client.setOperator({
+        validator: options.validator as Address,
+        operator: options.operator as Address,
+      });
+
+      const output = {
+        transactionHash: result.transactionHash,
+        validator: options.validator,
+        newOperator: options.operator,
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Operator updated!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to set operator", error.message || error);
+    }
+  }
+}

package/src/commands/staking/stakingInfo.ts

@@ -0,0 +1,300 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+// Epoch-related constants
+const ACTIVATION_DELAY_EPOCHS = 2n;
+const UNBONDING_PERIOD_EPOCHS = 7n;
+
+export interface StakingInfoOptions extends StakingConfig {
+  validator?: string;
+}
+
+export class StakingInfoAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async getValidatorInfo(options: StakingInfoOptions): Promise<void> {
+    this.startSpinner("Fetching validator info...");
+
+    try {
+      const client = await this.getReadOnlyStakingClient(options);
+      const validatorAddress = options.validator || (await this.getSignerAddress());
+
+      const isValidator = await client.isValidator(validatorAddress as Address);
+
+      if (!isValidator) {
+        this.failSpinner(`Address ${validatorAddress} is not a validator`);
+        return;
+      }
+
+      const [info, epochInfo] = await Promise.all([
+        client.getValidatorInfo(validatorAddress as Address),
+        client.getEpochInfo(),
+      ]);
+
+      const currentEpoch = epochInfo.currentEpoch;
+
+      const result: Record<string, any> = {
+        validator: info.address,
+        owner: info.owner,
+        operator: info.operator,
+        vStake: info.vStake,
+        vShares: info.vShares.toString(),
+        dStake: info.dStake,
+        dShares: info.dShares.toString(),
+        vDeposit: info.vDeposit,
+        vWithdrawal: info.vWithdrawal,
+        ePrimed: info.ePrimed.toString(),
+        needsPriming: info.needsPriming,
+        live: info.live,
+        banned: info.banned ? info.bannedEpoch?.toString() : "Not banned",
+        selfStakePendingDeposits: (() => {
+          // Filter to only truly pending deposits (not yet active)
+          const pending = info.pendingDeposits.filter(d => d.epoch + ACTIVATION_DELAY_EPOCHS > currentEpoch);
+          return pending.length > 0
+            ? pending.map(d => {
+                const depositEpoch = d.epoch;
+                const activationEpoch = depositEpoch + ACTIVATION_DELAY_EPOCHS;
+                const epochsUntilActive = activationEpoch - currentEpoch;
+                return {
+                  epoch: depositEpoch.toString(),
+                  stake: d.stake,
+                  shares: d.shares.toString(),
+                  activatesAtEpoch: activationEpoch.toString(),
+                  epochsRemaining: epochsUntilActive.toString(),
+                };
+              })
+            : "None";
+        })(),
+        selfStakePendingWithdrawals:
+          info.pendingWithdrawals.length > 0
+            ? info.pendingWithdrawals.map(w => {
+                const exitEpoch = w.epoch;
+                const claimableEpoch = exitEpoch + UNBONDING_PERIOD_EPOCHS;
+                const epochsUntilClaimable = claimableEpoch - currentEpoch;
+                return {
+                  epoch: exitEpoch.toString(),
+                  shares: w.shares.toString(),
+                  stake: w.stake,
+                  claimableAtEpoch: claimableEpoch.toString(),
+                  status:
+                    epochsUntilClaimable <= 0n
+                      ? "Claimable now"
+                      : `Unbonding (${epochsUntilClaimable} epoch${epochsUntilClaimable > 1n ? "s" : ""} remaining)`,
+                };
+              })
+            : "None",
+      };
+
+      // Add identity if set
+      if (info.identity?.moniker) {
+        result.identity = {
+          moniker: info.identity.moniker,
+          ...(info.identity.website && {website: info.identity.website}),
+          ...(info.identity.description && {description: info.identity.description}),
+          ...(info.identity.twitter && {twitter: info.identity.twitter}),
+          ...(info.identity.telegram && {telegram: info.identity.telegram}),
+          ...(info.identity.github && {github: info.identity.github}),
+          ...(info.identity.email && {email: info.identity.email}),
+          ...(info.identity.logoUri && {logoUri: info.identity.logoUri}),
+        };
+      }
+
+      this.succeedSpinner("Validator info retrieved", result);
+    } catch (error: any) {
+      this.failSpinner("Failed to get validator info", error.message || error);
+    }
+  }
+
+  async getStakeInfo(options: StakingInfoOptions & {delegator?: string}): Promise<void> {
+    this.startSpinner("Fetching stake info...");
+
+    try {
+      const client = await this.getReadOnlyStakingClient(options);
+      const delegatorAddress = options.delegator || (await this.getSignerAddress());
+      const isOwnDelegation = !options.delegator;
+
+      this.setSpinnerText(`Fetching delegation info for ${delegatorAddress}...`);
+
+      if (!options.validator) {
+        this.failSpinner("Validator address is required");
+        return;
+      }
+
+      const [info, epochInfo] = await Promise.all([
+        client.getStakeInfo(delegatorAddress as Address, options.validator as Address),
+        client.getEpochInfo(),
+      ]);
+
+      const currentEpoch = epochInfo.currentEpoch;
+
+      // Calculate projected rewards
+      let projectedReward = "N/A";
+      if (epochInfo.totalWeight > 0n && epochInfo.inflationRaw > 0n && info.stakeRaw > 0n) {
+        const rewardRaw = (info.stakeRaw * epochInfo.inflationRaw) / epochInfo.totalWeight;
+        projectedReward = client.formatStakingAmount(rewardRaw) + " per epoch";
+      } else if (epochInfo.inflationRaw === 0n) {
+        projectedReward = "0 GEN (no inflation this epoch)";
+      }
+
+      const result = {
+        delegator: info.delegator,
+        validator: info.validator,
+        shares: info.shares.toString(),
+        stake: info.stake,
+        projectedReward,
+        pendingDeposits: (() => {
+          // Filter to only truly pending deposits (not yet active)
+          const pending = info.pendingDeposits.filter(d => d.epoch + ACTIVATION_DELAY_EPOCHS > currentEpoch);
+          return pending.length > 0
+            ? pending.map(d => {
+                const depositEpoch = d.epoch;
+                const activationEpoch = depositEpoch + ACTIVATION_DELAY_EPOCHS;
+                const epochsUntilActive = activationEpoch - currentEpoch;
+                return {
+                  epoch: depositEpoch.toString(),
+                  stake: d.stake,
+                  shares: d.shares.toString(),
+                  activatesAtEpoch: activationEpoch.toString(),
+                  epochsRemaining: epochsUntilActive.toString(),
+                };
+              })
+            : "None";
+        })(),
+        pendingWithdrawals:
+          info.pendingWithdrawals.length > 0
+            ? info.pendingWithdrawals.map(w => {
+                const exitEpoch = w.epoch;
+                const claimableEpoch = exitEpoch + UNBONDING_PERIOD_EPOCHS; // Must wait 7 full epochs
+                const epochsUntilClaimable = claimableEpoch - currentEpoch;
+                return {
+                  epoch: exitEpoch.toString(),
+                  shares: w.shares.toString(),
+                  stake: w.stake,
+                  claimableAtEpoch: claimableEpoch.toString(),
+                  status:
+                    epochsUntilClaimable <= 0n
+                      ? "Claimable now"
+                      : `Unbonding (${epochsUntilClaimable} epoch${epochsUntilClaimable > 1n ? "s" : ""} remaining)`,
+                };
+              })
+            : "None",
+      };
+
+      const msg = isOwnDelegation ? "Your delegation info" : `Delegation info for ${delegatorAddress}`;
+      this.succeedSpinner(msg, result);
+    } catch (error: any) {
+      this.failSpinner("Failed to get stake info", error.message || error);
+    }
+  }
+
+  async getEpochInfo(options: StakingConfig): Promise<void> {
+    this.startSpinner("Fetching epoch info...");
+
+    try {
+      const client = await this.getReadOnlyStakingClient(options);
+
+      const info = await client.getEpochInfo();
+
+      const formatDuration = (ms: number): string => {
+        const hours = Math.floor(ms / (1000 * 60 * 60));
+        const minutes = Math.floor((ms % (1000 * 60 * 60)) / (1000 * 60));
+        if (hours > 24) {
+          const days = Math.floor(hours / 24);
+          const remainingHours = hours % 24;
+          return `${days}d ${remainingHours}h ${minutes}m`;
+        }
+        return `${hours}h ${minutes}m`;
+      };
+
+      const now = Date.now();
+      const timeUntilNext = info.nextEpochEstimate ? info.nextEpochEstimate.getTime() - now : null;
+
+      const result = {
+        currentEpoch: info.currentEpoch.toString(),
+        epochStarted: info.currentEpochStart.toISOString(),
+        epochEnded: info.currentEpochEnd?.toISOString() || "Not ended",
+        nextEpochEstimate: info.nextEpochEstimate?.toISOString() || "N/A",
+        timeUntilNextEpoch: timeUntilNext && timeUntilNext > 0 ? formatDuration(timeUntilNext) : "N/A",
+        minEpochDuration: formatDuration(Number(info.epochMinDuration) * 1000),
+        validatorMinStake: info.validatorMinStake,
+        delegatorMinStake: info.delegatorMinStake,
+        activeValidatorsCount: info.activeValidatorsCount.toString(),
+        // Inflation/rewards
+        epochInflation: info.inflation,
+        totalWeight: info.totalWeight.toString(),
+        totalClaimed: info.totalClaimed,
+      };
+
+      this.succeedSpinner("Epoch info retrieved", result);
+    } catch (error: any) {
+      this.failSpinner("Failed to get epoch info", error.message || error);
+    }
+  }
+
+  async listActiveValidators(options: StakingConfig): Promise<void> {
+    this.startSpinner("Fetching active validators...");
+
+    try {
+      const client = await this.getReadOnlyStakingClient(options);
+
+      const activeValidators = await client.getActiveValidators();
+
+      const result = {
+        count: activeValidators.length,
+        validators: activeValidators,
+      };
+
+      this.succeedSpinner("Active validators retrieved", result);
+    } catch (error: any) {
+      this.failSpinner("Failed to get active validators", error.message || error);
+    }
+  }
+
+  async listQuarantinedValidators(options: StakingConfig): Promise<void> {
+    this.startSpinner("Fetching quarantined validators...");
+
+    try {
+      const client = await this.getReadOnlyStakingClient(options);
+
+      const validators = await client.getQuarantinedValidatorsDetailed();
+
+      const result = {
+        count: validators.length,
+        validators: validators.map(v => ({
+          validator: v.validator,
+          untilEpoch: v.untilEpoch.toString(),
+          permanentlyBanned: v.permanentlyBanned,
+        })),
+      };
+
+      this.succeedSpinner("Quarantined validators retrieved", result);
+    } catch (error: any) {
+      this.failSpinner("Failed to get quarantined validators", error.message || error);
+    }
+  }
+
+  async listBannedValidators(options: StakingConfig): Promise<void> {
+    this.startSpinner("Fetching banned validators...");
+
+    try {
+      const client = await this.getReadOnlyStakingClient(options);
+
+      const validators = await client.getBannedValidators();
+
+      const result = {
+        count: validators.length,
+        validators: validators.map(v => ({
+          validator: v.validator,
+          untilEpoch: v.permanentlyBanned ? "permanent" : v.untilEpoch.toString(),
+          permanentlyBanned: v.permanentlyBanned,
+        })),
+      };
+
+      this.succeedSpinner("Banned validators retrieved", result);
+    } catch (error: any) {
+      this.failSpinner("Failed to get banned validators", error.message || error);
+    }
+  }
+}

package/src/commands/staking/validatorClaim.ts

@@ -0,0 +1,38 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+export interface ValidatorClaimOptions extends StakingConfig {
+  validator?: string;
+}
+
+export class ValidatorClaimAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorClaimOptions): Promise<void> {
+    this.startSpinner("Claiming validator withdrawals...");
+
+    try {
+      const client = await this.getStakingClient(options);
+      const validatorAddress = options.validator || (await this.getSignerAddress());
+
+      this.setSpinnerText(`Claiming for validator ${validatorAddress}...`);
+
+      const result = await client.validatorClaim({
+        validator: validatorAddress as Address,
+      });
+
+      const output = {
+        transactionHash: result.transactionHash,
+        validator: validatorAddress,
+        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/validatorDeposit.ts

@@ -0,0 +1,35 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+
+export interface ValidatorDepositOptions extends StakingConfig {
+  amount: string;
+}
+
+export class ValidatorDepositAction extends StakingAction {
+  constructor() {
+    super();
+  }
+
+  async execute(options: ValidatorDepositOptions): Promise<void> {
+    this.startSpinner("Making validator deposit...");
+
+    try {
+      const client = await this.getStakingClient(options);
+      const amount = this.parseAmount(options.amount);
+
+      this.setSpinnerText(`Depositing ${this.formatAmount(amount)} to validator stake...`);
+
+      const result = await client.validatorDeposit({amount});
+
+      const output = {
+        transactionHash: result.transactionHash,
+        amount: this.formatAmount(amount),
+        blockNumber: result.blockNumber.toString(),
+        gasUsed: result.gasUsed.toString(),
+      };
+
+      this.succeedSpinner("Deposit successful!", output);
+    } catch (error: any) {
+      this.failSpinner("Failed to make deposit", error.message || error);
+    }
+  }
+}

package/src/commands/staking/validatorExit.ts

@@ -0,0 +1,44 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+
+export interface ValidatorExitOptions extends StakingConfig {
+  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 client = await this.getStakingClient(options);
+
+      this.setSpinnerText(`Exiting with ${shares} shares...`);
+
+      const result = await client.validatorExit({shares});
+
+      const output = {
+        transactionHash: result.transactionHash,
+        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/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,35 @@
+import {StakingAction, StakingConfig} from "./StakingAction";
+import type {Address} from "genlayer-js/types";
+
+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);
+    }
+  }
+}