genlayer-js 0.18.3 → 0.18.5

package/src/staking/utils.ts

@@ -0,0 +1,22 @@
+import {parseEther, formatEther} from "viem";
+
+/**
+ * Parse staking amount. Use "gen" suffix for GEN tokens (e.g. "42gen"),
+ * otherwise value is treated as wei (e.g. "42000000000000000000" = 42 GEN).
+ */
+export function parseStakingAmount(amount: string | bigint): bigint {
+  if (typeof amount === "bigint") return amount;
+  const trimmed = amount.trim();
+  const lower = trimmed.toLowerCase();
+  if (lower.endsWith("gen")) {
+    return parseEther(lower.slice(0, -3).trim());
+  }
+  return BigInt(trimmed);
+}
+
+/**
+ * Format bigint amount to human-readable GEN string.
+ */
+export function formatStakingAmount(amount: bigint): string {
+  return `${formatEther(amount)} GEN`;
+}

package/src/transactions/actions.ts

@@ -14,8 +14,6 @@ import {Abi, PublicClient, Address} from "viem";
 import {localnet} from "@/chains/localnet";
 import {decodeLocalnetTransaction, decodeTransaction, simplifyTransactionReceipt} from "./decoders";
 
-
-
 export const receiptActions = (client: GenLayerClient<GenLayerChain>, publicClient: PublicClient) => ({
   waitForTransactionReceipt: async ({
     hash,
@@ -70,7 +68,7 @@ export const receiptActions = (client: GenLayerClient<GenLayerChain>, publicClie
 
 export const transactionActions = (client: GenLayerClient<GenLayerChain>, publicClient: PublicClient) => ({
   getTransaction: async ({hash}: {hash: TransactionHash}): Promise<GenLayerTransaction> => {
-    if (client.chain.id === localnet.id) {
+    if (client.chain.isStudio) {
       const transaction = await client.getTransaction({hash});
       const localnetStatus =
         (transaction.status as string) === "ACTIVATED" ? TransactionStatus.PENDING : transaction.status;
@@ -100,16 +98,16 @@ export const transactionActions = (client: GenLayerClient<GenLayerChain>, public
       from: transactionParams.from || client.account?.address,
       to: transactionParams.to,
       data: transactionParams.data || "0x",
-      value: transactionParams.value ? `0x${transactionParams.value.toString(16)}` as `0x${string}` : "0x0" as `0x${string}`,
+      value: transactionParams.value
+        ? (`0x${transactionParams.value.toString(16)}` as `0x${string}`)
+        : ("0x0" as `0x${string}`),
     };
 
-    const gasHex = await client.request({
+    const gasHex = (await client.request({
       method: "eth_estimateGas",
       params: [formattedParams],
-    }) as string;
+    })) as string;
 
     return BigInt(gasHex);
   },
 });
-
-

package/src/types/chains.ts

@@ -2,16 +2,21 @@ import {Chain} from "viem";
 import {Address} from "./accounts";
 
 export type GenLayerChain = Chain & {
+  isStudio: boolean;
   consensusMainContract: {
     address: Address;
-    abi: any[];
+    abi: readonly unknown[];
     bytecode: string;
   } | null;
   consensusDataContract: {
     address: Address;
-    abi: any[];
+    abi: readonly unknown[];
     bytecode: string;
   } | null;
+  stakingContract: {
+    address: Address;
+    abi: readonly unknown[];
+  } | null;
   defaultNumberOfInitialValidators: number;
   defaultConsensusMaxRotations: number;
 };

package/src/types/clients.ts

@@ -7,6 +7,7 @@ import {ContractSchema} from "./contracts";
 import {Network} from "./network";
 import {SnapSource} from "@/types/snapSource";
 import {MetaMaskClientResult} from "@/types/metamaskClientResult";
+import {StakingActions} from "./staking";
 
 export type GenLayerMethod =
   | {method: "sim_fundAccount"; params: [address: Address, amount: number]}
@@ -22,14 +23,13 @@ export type GenLayerMethod =
   | {method: "gen_call"; params: [requestParams: any]};
 
 /*
-  Take all the properties from PublicActions<Transport, TGenLayerChain>
-  Remove the transport, readContract, and getTransaction properties
-  The resulting type will have everything from PublicActions EXCEPT those
-  two properties which are added later
+  Take all the properties from Client<Transport, TGenLayerChain>
+  Remove getTransaction and readContract because they are redefined with custom implementations.
+  Keep transport as it's needed for viem contract interactions (e.g., staking).
 */
 export type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<
   Client<Transport, TGenLayerChain>,
-  "transport" | "getTransaction" | "readContract"
+  "getTransaction" | "readContract"
 > &
   Omit<WalletActions<TGenLayerChain>, "deployContract" | "writeContract"> &
   Omit<
@@ -103,4 +103,4 @@ export type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<
       account?: Account;
       txId: `0x${string}`;
     }) => Promise<any>;
-  };
+  } & StakingActions;

package/src/types/index.ts

@@ -6,3 +6,4 @@ export * from "./contracts";
 export * from "./transactions";
 export * from "./network";
 export * from "./snapSource";
+export * from "./staking";

package/src/types/staking.ts

@@ -0,0 +1,228 @@
+import {Address} from "./accounts";
+import {GetContractReturnType, PublicClient, Client, Transport, Chain, Account, Address as ViemAddress} from "viem";
+import {STAKING_ABI} from "@/abi/staking";
+
+type WalletClientWithAccount = Client<Transport, Chain, Account>;
+
+type StakingKeyedClient = {
+  public: PublicClient;
+  wallet: WalletClientWithAccount;
+};
+
+export type StakingContract = GetContractReturnType<
+  typeof STAKING_ABI,
+  StakingKeyedClient,
+  ViemAddress
+>;
+
+export interface ValidatorView {
+  left: Address;
+  right: Address;
+  parent: Address;
+  eBanned: bigint;
+  ePrimed: bigint;
+  vStake: bigint;
+  vShares: bigint;
+  dStake: bigint;
+  dShares: bigint;
+  vDeposit: bigint;
+  vWithdrawal: bigint;
+  live: boolean;
+}
+
+export interface ValidatorIdentity {
+  moniker: string;
+  logoUri: string;
+  website: string;
+  description: string;
+  email: string;
+  twitter: string;
+  telegram: string;
+  github: string;
+  extraCid: string;
+}
+
+export interface ValidatorInfo {
+  address: Address;
+  owner: Address;
+  operator: Address;
+  vStake: string;
+  vStakeRaw: bigint;
+  vShares: bigint;
+  dStake: string;
+  dStakeRaw: bigint;
+  dShares: bigint;
+  vDeposit: string;
+  vDepositRaw: bigint;
+  vWithdrawal: string;
+  vWithdrawalRaw: bigint;
+  ePrimed: bigint;
+  live: boolean;
+  banned: boolean;
+  bannedEpoch?: bigint;
+  needsPriming: boolean;
+  identity?: ValidatorIdentity;
+  pendingDeposits: PendingDeposit[];
+  pendingWithdrawals: PendingWithdrawal[];
+}
+
+export interface WithdrawalCommit {
+  input: bigint;
+  output: bigint;
+  epoch: bigint;
+  linkToNextCommit: bigint;
+}
+
+export interface PendingDeposit {
+  epoch: bigint;
+  stake: string;
+  stakeRaw: bigint;
+  shares: bigint;
+}
+
+export interface PendingWithdrawal {
+  epoch: bigint;
+  shares: bigint;
+  stake: string;
+  stakeRaw: bigint;
+}
+
+export interface BannedValidatorInfo {
+  validator: Address;
+  untilEpoch: bigint;
+  permanentlyBanned: boolean;
+}
+
+export interface StakeInfo {
+  delegator: Address;
+  validator: Address;
+  shares: bigint;
+  stake: string;
+  stakeRaw: bigint;
+  pendingDeposits: PendingDeposit[];
+  pendingWithdrawals: PendingWithdrawal[];
+}
+
+export interface EpochData {
+  start: bigint;
+  end: bigint;
+  inflation: bigint;
+  weight: bigint;
+  weightDeposit: bigint;
+  weightWithdrawal: bigint;
+  vcount: bigint;
+  claimed: bigint;
+  stakeDeposit: bigint;
+  stakeWithdrawal: bigint;
+}
+
+export interface EpochInfo {
+  currentEpoch: bigint;
+  validatorMinStake: string;
+  validatorMinStakeRaw: bigint;
+  delegatorMinStake: string;
+  delegatorMinStakeRaw: bigint;
+  activeValidatorsCount: bigint;
+  epochMinDuration: bigint;
+  currentEpochStart: Date;
+  currentEpochEnd: Date | null;
+  nextEpochEstimate: Date | null;
+  inflation: string;
+  inflationRaw: bigint;
+  totalWeight: bigint;
+  totalClaimed: string;
+  totalClaimedRaw: bigint;
+}
+
+export interface StakingTransactionResult {
+  transactionHash: `0x${string}`;
+  blockNumber: bigint;
+  gasUsed: bigint;
+}
+
+export interface ValidatorJoinResult extends StakingTransactionResult {
+  validatorWallet: Address;
+  operator: Address;
+  amount: string;
+  amountRaw: bigint;
+}
+
+export interface DelegatorJoinResult extends StakingTransactionResult {
+  validator: Address;
+  delegator: Address;
+  amount: string;
+  amountRaw: bigint;
+}
+
+export interface ValidatorJoinOptions {
+  amount: bigint | string;
+  operator?: Address;
+}
+
+export interface ValidatorDepositOptions {
+  amount: bigint | string;
+}
+
+export interface ValidatorExitOptions {
+  shares: bigint | string;
+}
+
+export interface ValidatorClaimOptions {
+  validator?: Address;
+}
+
+export interface ValidatorPrimeOptions {
+  validator: Address;
+}
+
+export interface SetOperatorOptions {
+  validator: Address;
+  operator: Address;
+}
+
+export interface SetIdentityOptions {
+  validator: Address;
+  moniker: string;
+  logoUri?: string;
+  website?: string;
+  description?: string;
+  email?: string;
+  twitter?: string;
+  telegram?: string;
+  github?: string;
+  extraCid?: string;
+}
+
+export interface DelegatorJoinOptions {
+  validator: Address;
+  amount: bigint | string;
+}
+
+export interface DelegatorExitOptions {
+  validator: Address;
+  shares: bigint | string;
+}
+
+export interface DelegatorClaimOptions {
+  validator: Address;
+  delegator?: Address;
+}
+
+export interface StakingActions {
+  validatorJoin: (options: ValidatorJoinOptions) => Promise<ValidatorJoinResult>;
+  validatorDeposit: (options: ValidatorDepositOptions) => Promise<StakingTransactionResult>;
+  validatorExit: (options: ValidatorExitOptions) => Promise<StakingTransactionResult>;
+  validatorClaim: (options?: ValidatorClaimOptions) => Promise<StakingTransactionResult & {claimedAmount: bigint}>;
+  delegatorJoin: (options: DelegatorJoinOptions) => Promise<DelegatorJoinResult>;
+  delegatorExit: (options: DelegatorExitOptions) => Promise<StakingTransactionResult>;
+  delegatorClaim: (options: DelegatorClaimOptions) => Promise<StakingTransactionResult>;
+  isValidator: (address: Address) => Promise<boolean>;
+  getValidatorInfo: (validator: Address) => Promise<ValidatorInfo>;
+  getStakeInfo: (delegator: Address, validator: Address) => Promise<StakeInfo>;
+  getEpochInfo: () => Promise<EpochInfo>;
+  getActiveValidators: () => Promise<Address[]>;
+  getActiveValidatorsCount: () => Promise<bigint>;
+  getStakingContract: () => StakingContract;
+  parseStakingAmount: (amount: string | bigint) => bigint;
+  formatStakingAmount: (amount: bigint) => string;
+}

package/tsconfig.vitest-temp.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ],
+      "@@/tests/*": [
+        "./tests/*"
+      ]
+    },
+    "rootDirs": [
+      "./src",
+      "./tests"
+    ],
+    "types": [
+      "node",
+      "jest"
+    ],
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "emitDeclarationOnly": false,
+    "incremental": true,
+    "tsBuildInfoFile": "./node_modules/.cache/tsconfig.vitest.tsbuildinfo"
+  },
+  "include": [
+    "src/**/*",
+    "tests/**/*",
+    "src/global.d.ts"
+  ],
+  "exclude": [
+    "./dist"
+  ]
+}