genlayer-js 0.18.9 → 0.18.11

package/src/chains/testnetAsimov.ts

@@ -3,15 +3,16 @@ import {GenLayerChain} from "@/types";
 import {STAKING_ABI} from "@/abi/staking";
 
 // chains/localnet.ts
-const TESTNET_JSON_RPC_URL = "https://genlayer-testnet.rpc.caldera.xyz/http";
+const TESTNET_JSON_RPC_URL = "https://zksync-os-testnet-genlayer.zksync.dev";
+const TESTNET_WS_URL = "wss://zksync-os-testnet-genlayer.zksync.dev/ws";
 
 const STAKING_CONTRACT = {
-  address: "0x03f410748EBdb4026a6b8299E9B6603A273709D1" as Address,
+  address: "0x63Fa5E0bb10fb6fA98F44726C5518223F767687A" as Address,
   abi: STAKING_ABI,
 };
 const EXPLORER_URL = "https://explorer-asimov.genlayer.com/";
 const CONSENSUS_MAIN_CONTRACT = {
-  address: "0x67fd4aC71530FB220E0B7F90668BAF977B88fF07" as Address,
+  address: "0x6CAFF6769d70824745AD895663409DC70aB5B28E" as Address,
   abi: [
     {
       inputs: [],
@@ -1401,7 +1402,7 @@ const CONSENSUS_MAIN_CONTRACT = {
 };
 
 const CONSENSUS_DATA_CONTRACT = {
-  address: "0xB6E1316E57d47d82FDcEa5002028a554754EF243" as Address,
+  address: "0x0D9d1d74d72Fa5eB94bcf746C8FCcb312a722c9B" as Address,
   abi: [
     {
       inputs: [],
@@ -3989,6 +3990,7 @@ export const testnetAsimov: GenLayerChain = defineChain({
   rpcUrls: {
     default: {
       http: [TESTNET_JSON_RPC_URL],
+      webSocket: [TESTNET_WS_URL],
     },
   },
   nativeCurrency: {

package/src/staking/actions.ts

@@ -561,8 +561,6 @@ export const stakingActions = (
       const [
         epoch,
         finalized,
-        validatorMinStake,
-        delegatorMinStake,
         activeCount,
         epochMinDuration,
         epochZeroMinDuration,
@@ -571,8 +569,6 @@ export const stakingActions = (
       ] = await Promise.all([
         contract.read.epoch() as Promise<bigint>,
         contract.read.finalized() as Promise<bigint>,
-        contract.read.validatorMinStake() as Promise<bigint>,
-        contract.read.delegatorMinStake() as Promise<bigint>,
         contract.read.activeValidatorsCount() as Promise<bigint>,
         contract.read.epochMinDuration() as Promise<bigint>,
         contract.read.epochZeroMinDuration() as Promise<bigint>,
@@ -580,8 +576,21 @@ export const stakingActions = (
         contract.read.epochEven() as Promise<any>,
       ]);
 
-      // Current epoch data for next epoch estimate
-      const currentEpochData = epoch % 2n === 0n ? epochEven : epochOdd;
+      // epochOdd/epochEven return arrays: [start, end, inflation, weight, weightDeposit, weightWithdrawal, vcount, claimed, stakeDeposit, stakeWithdrawal, slashed]
+      const raw = epoch % 2n === 0n ? epochEven : epochOdd;
+      const currentEpochData = {
+        start: raw[0] as bigint,
+        end: raw[1] as bigint,
+        inflation: raw[2] as bigint,
+        weight: raw[3] as bigint,
+        weightDeposit: raw[4] as bigint,
+        weightWithdrawal: raw[5] as bigint,
+        vcount: raw[6] as bigint,
+        claimed: raw[7] as bigint,
+        stakeDeposit: raw[8] as bigint,
+        stakeWithdrawal: raw[9] as bigint,
+        slashed: raw[10] as bigint,
+      };
       const currentEpochEnd = currentEpochData.end > 0n;
 
       // Estimate next epoch: current start + min duration (if epoch hasn't ended)
@@ -595,10 +604,6 @@ export const stakingActions = (
       return {
         currentEpoch: epoch,
         lastFinalizedEpoch: finalized,
-        validatorMinStake: formatStakingAmount(validatorMinStake),
-        validatorMinStakeRaw: validatorMinStake,
-        delegatorMinStake: formatStakingAmount(delegatorMinStake),
-        delegatorMinStakeRaw: delegatorMinStake,
         activeValidatorsCount: activeCount,
         epochMinDuration,
         nextEpochEstimate,
@@ -624,20 +629,21 @@ export const stakingActions = (
         throw new Error(`Epoch ${epochNumber} data no longer available (only current and previous epoch stored)`);
       }
 
-      const epochData = epochNumber % 2n === 0n ? epochEven : epochOdd;
+      // epochOdd/epochEven return arrays: [start, end, inflation, weight, weightDeposit, weightWithdrawal, vcount, claimed, stakeDeposit, stakeWithdrawal, slashed]
+      const raw = epochNumber % 2n === 0n ? epochEven : epochOdd;
 
       return {
-        start: epochData.start,
-        end: epochData.end,
-        inflation: epochData.inflation,
-        weight: epochData.weight,
-        weightDeposit: epochData.weightDeposit,
-        weightWithdrawal: epochData.weightWithdrawal,
-        vcount: epochData.vcount,
-        claimed: epochData.claimed,
-        stakeDeposit: epochData.stakeDeposit,
-        stakeWithdrawal: epochData.stakeWithdrawal,
-        slashed: epochData.slashed,
+        start: raw[0] as bigint,
+        end: raw[1] as bigint,
+        inflation: raw[2] as bigint,
+        weight: raw[3] as bigint,
+        weightDeposit: raw[4] as bigint,
+        weightWithdrawal: raw[5] as bigint,
+        vcount: raw[6] as bigint,
+        claimed: raw[7] as bigint,
+        stakeDeposit: raw[8] as bigint,
+        stakeWithdrawal: raw[9] as bigint,
+        slashed: raw[10] as bigint,
       };
     },
 
@@ -654,7 +660,7 @@ export const stakingActions = (
 
     getQuarantinedValidators: async (): Promise<Address[]> => {
       const contract = getReadOnlyStakingContract();
-      return contract.read.getQuarantinedValidators() as Promise<Address[]>;
+      return contract.read.getValidatorQuarantineList() as Promise<Address[]>;
     },
 
     getBannedValidators: async (startIndex = 0n, size = 100n): Promise<BannedValidatorInfo[]> => {
@@ -677,13 +683,6 @@ export const stakingActions = (
       }));
     },
 
-    getSlashingAddress: async (): Promise<Address> => {
-      const contract = getReadOnlyStakingContract();
-      // contracts() returns tuple: [gen, transactions, idleness, tribunal, slashing, consensus, validatorWalletFactory, nftMinter]
-      const externalContracts = (await contract.read.contracts()) as readonly ViemAddress[];
-      return externalContracts[4] as Address; // slashing is at index 4
-    },
-
     getStakingContract,
     parseStakingAmount,
     formatStakingAmount,

package/src/types/staking.ts

@@ -120,10 +120,6 @@ export interface EpochData {
 export interface EpochInfo {
   currentEpoch: bigint;
   lastFinalizedEpoch: bigint;
-  validatorMinStake: string;
-  validatorMinStakeRaw: bigint;
-  delegatorMinStake: string;
-  delegatorMinStakeRaw: bigint;
   activeValidatorsCount: bigint;
   epochMinDuration: bigint;
   nextEpochEstimate: Date | null;
@@ -218,7 +214,6 @@ export interface StakingActions {
   getEpochData: (epochNumber: bigint) => Promise<EpochData>;
   getActiveValidators: () => Promise<Address[]>;
   getActiveValidatorsCount: () => Promise<bigint>;
-  getSlashingAddress: () => Promise<Address>;
   getStakingContract: () => StakingContract;
   parseStakingAmount: (amount: string | bigint) => bigint;
   formatStakingAmount: (amount: bigint) => string;

package/tests/smoke.test.ts

@@ -0,0 +1,291 @@
+// tests/smoke.test.ts
+// Smoke tests against live testnet-asimov to verify ABI compatibility and connectivity.
+// Run with: npm run test:smoke
+// These are excluded from regular `npm test` to avoid CI dependence on testnet availability.
+
+import {describe, it, expect, beforeAll} from "vitest";
+import {createPublicClient, http, webSocket, getContract, Address as ViemAddress} from "viem";
+import {testnetAsimov} from "@/chains/testnetAsimov";
+import {createClient} from "@/client/client";
+import {STAKING_ABI} from "@/abi/staking";
+import {Address} from "@/types/accounts";
+
+const TIMEOUT = 30_000;
+
+// ─── HTTP RPC Connectivity ───────────────────────────────────────────────────
+
+describe("Testnet Asimov - HTTP RPC", () => {
+  it("should fetch chain ID", async () => {
+    const client = createPublicClient({
+      chain: testnetAsimov,
+      transport: http(testnetAsimov.rpcUrls.default.http[0]),
+    });
+    const chainId = await client.getChainId();
+    expect(chainId).toBe(testnetAsimov.id);
+  }, TIMEOUT);
+
+  it("should fetch latest block number", async () => {
+    const client = createPublicClient({
+      chain: testnetAsimov,
+      transport: http(testnetAsimov.rpcUrls.default.http[0]),
+    });
+    const blockNumber = await client.getBlockNumber();
+    expect(blockNumber).toBeGreaterThan(0n);
+  }, TIMEOUT);
+});
+
+// ─── WebSocket RPC Connectivity ──────────────────────────────────────────────
+
+describe("Testnet Asimov - WebSocket RPC", () => {
+  const wsUrl = testnetAsimov.rpcUrls.default.webSocket?.[0];
+
+  it("should have a WS URL configured", () => {
+    expect(wsUrl).toBeDefined();
+    expect(wsUrl).toMatch(/^wss?:\/\//);
+  });
+
+  it("should connect and fetch chain ID over WebSocket", async () => {
+    if (!wsUrl) return;
+    const client = createPublicClient({
+      chain: testnetAsimov,
+      transport: webSocket(wsUrl),
+    });
+    const chainId = await client.getChainId();
+    // WS endpoint may point to the underlying chain (different ID from GenLayer overlay)
+    // The key assertion is that the connection works and returns a valid number
+    expect(chainId).toBeTypeOf("number");
+    expect(chainId).toBeGreaterThan(0);
+    if (chainId !== testnetAsimov.id) {
+      console.warn(
+        `WS chain ID (${chainId}) differs from HTTP chain ID (${testnetAsimov.id}). ` +
+        `WS URL may point to the underlying L1/L2 chain.`
+      );
+    }
+  }, TIMEOUT);
+
+  it("should fetch latest block number over WebSocket", async () => {
+    if (!wsUrl) return;
+    const client = createPublicClient({
+      chain: testnetAsimov,
+      transport: webSocket(wsUrl),
+    });
+    const blockNumber = await client.getBlockNumber();
+    expect(blockNumber).toBeGreaterThan(0n);
+  }, TIMEOUT);
+});
+
+// ─── Staking Read-Only via WebSocket ─────────────────────────────────────────
+
+describe("Testnet Asimov - Staking over WebSocket", () => {
+  const wsUrl = testnetAsimov.rpcUrls.default.webSocket?.[0];
+  const stakingAddress = testnetAsimov.stakingContract?.address as ViemAddress;
+
+  // First check if WS points to the same chain — if not, skip staking tests
+  let wsMatchesChain = false;
+  let wsPub: ReturnType<typeof createPublicClient> | null = null;
+
+  beforeAll(async () => {
+    if (!wsUrl) return;
+    wsPub = createPublicClient({chain: testnetAsimov, transport: webSocket(wsUrl)});
+    try {
+      const chainId = await wsPub.getChainId();
+      wsMatchesChain = chainId === testnetAsimov.id;
+      if (!wsMatchesChain) {
+        console.warn(
+          `WS chain ID (${chainId}) differs from testnet (${testnetAsimov.id}). ` +
+          `Staking contract calls will be skipped — WS endpoint serves a different chain.`
+        );
+      }
+    } catch {
+      console.warn("WS connection failed during setup");
+    }
+  }, TIMEOUT);
+
+  it("epoch() via WS", async () => {
+    if (!wsMatchesChain || !wsPub) return;
+    const contract = getContract({address: stakingAddress, abi: STAKING_ABI, client: wsPub});
+    const epoch = await contract.read.epoch();
+    expect(epoch).toBeTypeOf("bigint");
+  }, TIMEOUT);
+
+  it("activeValidatorsCount() via WS", async () => {
+    if (!wsMatchesChain || !wsPub) return;
+    const contract = getContract({address: stakingAddress, abi: STAKING_ABI, client: wsPub});
+    const count = await contract.read.activeValidatorsCount();
+    expect(count).toBeTypeOf("bigint");
+    expect(count).toBeGreaterThanOrEqual(0n);
+  }, TIMEOUT);
+
+  it("activeValidators() via WS", async () => {
+    if (!wsMatchesChain || !wsPub) return;
+    const contract = getContract({address: stakingAddress, abi: STAKING_ABI, client: wsPub});
+    const validators = await contract.read.activeValidators();
+    expect(Array.isArray(validators)).toBe(true);
+  }, TIMEOUT);
+
+  it("isValidator() via WS", async () => {
+    if (!wsMatchesChain || !wsPub) return;
+    const contract = getContract({address: stakingAddress, abi: STAKING_ABI, client: wsPub});
+    const validators = (await contract.read.activeValidators()) as ViemAddress[];
+    const nonZero = validators.filter(v => v !== "0x0000000000000000000000000000000000000000");
+    if (nonZero.length === 0) return;
+
+    const result = await contract.read.isValidator([nonZero[0]]);
+    expect(result).toBe(true);
+  }, TIMEOUT);
+
+  it("validatorView() via WS", async () => {
+    if (!wsMatchesChain || !wsPub) return;
+    const contract = getContract({address: stakingAddress, abi: STAKING_ABI, client: wsPub});
+    const validators = (await contract.read.activeValidators()) as ViemAddress[];
+    const nonZero = validators.filter(v => v !== "0x0000000000000000000000000000000000000000");
+    if (nonZero.length === 0) return;
+
+    const view = await contract.read.validatorView([nonZero[0]]) as unknown as readonly unknown[];
+    expect(Array.isArray(view)).toBe(true);
+    // view is [left, right, parent, eBanned, ePrimed, vStake, vShares, dStake, dShares, vDeposit, vWithdrawal, live]
+    expect(view.length).toBe(12);
+  }, TIMEOUT);
+
+  it("getValidatorQuarantineList() via WS", async () => {
+    if (!wsMatchesChain || !wsPub) return;
+    const contract = getContract({address: stakingAddress, abi: STAKING_ABI, client: wsPub});
+    const list = await contract.read.getValidatorQuarantineList();
+    expect(Array.isArray(list)).toBe(true);
+  }, TIMEOUT);
+
+  it("epochOdd() / epochEven() via WS", async () => {
+    if (!wsMatchesChain || !wsPub) return;
+    const contract = getContract({address: stakingAddress, abi: STAKING_ABI, client: wsPub});
+    const odd = await contract.read.epochOdd();
+    const even = await contract.read.epochEven();
+    expect(Array.isArray(odd)).toBe(true);
+    expect(Array.isArray(even)).toBe(true);
+    expect(odd.length).toBe(11);
+    expect(even.length).toBe(11);
+  }, TIMEOUT);
+});
+
+// ─── Staking Read-Only Methods ───────────────────────────────────────────────
+
+describe("Testnet Asimov - Staking (read-only)", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeAll(() => {
+    client = createClient({chain: testnetAsimov});
+  });
+
+  it("getEpochInfo", async () => {
+    const info = await client.getEpochInfo();
+    expect(info.currentEpoch).toBeTypeOf("bigint");
+    expect(info.lastFinalizedEpoch).toBeTypeOf("bigint");
+    expect(info.activeValidatorsCount).toBeTypeOf("bigint");
+    expect(info.epochMinDuration).toBeTypeOf("bigint");
+    // nextEpochEstimate is Date | null
+    if (info.nextEpochEstimate !== null) {
+      expect(info.nextEpochEstimate).toBeInstanceOf(Date);
+    }
+  }, TIMEOUT);
+
+  it("getActiveValidatorsCount", async () => {
+    const count = await client.getActiveValidatorsCount();
+    expect(count).toBeTypeOf("bigint");
+    expect(count).toBeGreaterThanOrEqual(0n);
+  }, TIMEOUT);
+
+  it("getActiveValidators", async () => {
+    const validators = await client.getActiveValidators();
+    expect(Array.isArray(validators)).toBe(true);
+    // Each entry should be a hex address
+    for (const v of validators) {
+      expect(v).toMatch(/^0x[0-9a-fA-F]{40}$/);
+    }
+  }, TIMEOUT);
+
+  it("getEpochData for current epoch", async () => {
+    const {currentEpoch} = await client.getEpochInfo();
+    const data = await client.getEpochData(currentEpoch);
+    expect(data.start).toBeTypeOf("bigint");
+    expect(data.weight).toBeTypeOf("bigint");
+    expect(data.vcount).toBeTypeOf("bigint");
+  }, TIMEOUT);
+
+  it("isValidator returns boolean", async () => {
+    const validators = await client.getActiveValidators();
+    if (validators.length === 0) return; // nothing to test
+
+    const result = await client.isValidator(validators[0]);
+    expect(result).toBe(true);
+
+    // zero address should not be a validator
+    const fake = await client.isValidator("0x0000000000000000000000000000000000000001" as Address);
+    expect(fake).toBe(false);
+  }, TIMEOUT);
+
+  it("getValidatorInfo for an active validator", async () => {
+    const validators = await client.getActiveValidators();
+    if (validators.length === 0) return;
+
+    const info = await client.getValidatorInfo(validators[0]);
+    expect(info.address).toBe(validators[0]);
+    expect(info.owner).toMatch(/^0x[0-9a-fA-F]{40}$/);
+    expect(info.operator).toMatch(/^0x[0-9a-fA-F]{40}$/);
+    expect(info.vStakeRaw).toBeTypeOf("bigint");
+    expect(typeof info.live).toBe("boolean");
+    expect(typeof info.banned).toBe("boolean");
+    expect(typeof info.needsPriming).toBe("boolean");
+    expect(Array.isArray(info.pendingDeposits)).toBe(true);
+    expect(Array.isArray(info.pendingWithdrawals)).toBe(true);
+  }, TIMEOUT);
+
+  it("getStakeInfo for validator self-stake", async () => {
+    const validators = await client.getActiveValidators();
+    if (validators.length === 0) return;
+
+    const validatorAddr = validators[0];
+    // Self-stake: delegator = validator address
+    const stakeInfo = await client.getStakeInfo(validatorAddr, validatorAddr);
+    expect(stakeInfo.delegator).toBe(validatorAddr);
+    expect(stakeInfo.validator).toBe(validatorAddr);
+    expect(stakeInfo.shares).toBeTypeOf("bigint");
+    expect(stakeInfo.stakeRaw).toBeTypeOf("bigint");
+    expect(Array.isArray(stakeInfo.pendingDeposits)).toBe(true);
+    expect(Array.isArray(stakeInfo.pendingWithdrawals)).toBe(true);
+  }, TIMEOUT);
+
+  it("getQuarantinedValidators returns array", async () => {
+    // This calls getValidatorQuarantineList() — the v0.5 renamed function
+    const quarantined = await (client as any).getQuarantinedValidators();
+    expect(Array.isArray(quarantined)).toBe(true);
+  }, TIMEOUT);
+
+  it("getBannedValidators returns array", async () => {
+    const banned = await (client as any).getBannedValidators();
+    expect(Array.isArray(banned)).toBe(true);
+    for (const b of banned) {
+      expect(b.validator).toMatch(/^0x[0-9a-fA-F]{40}$/);
+      expect(b.untilEpoch).toBeTypeOf("bigint");
+      expect(typeof b.permanentlyBanned).toBe("boolean");
+    }
+  }, TIMEOUT);
+
+  it("getStakingContract returns a contract instance", () => {
+    const contract = client.getStakingContract();
+    expect(contract).toBeDefined();
+    expect(contract.address).toMatch(/^0x[0-9a-fA-F]{40}$/);
+    expect(contract.read).toBeDefined();
+  });
+
+  it("parseStakingAmount and formatStakingAmount round-trip", () => {
+    // parseStakingAmount treats bare strings as wei; use "gen" suffix for human amounts
+    const amount = client.parseStakingAmount("1.5gen");
+    expect(amount).toBeTypeOf("bigint");
+    expect(amount).toBe(1500000000000000000n);
+    const formatted = client.formatStakingAmount(amount);
+    expect(formatted).toBe("1.5 GEN");
+
+    // Raw wei round-trip
+    const weiAmount = client.parseStakingAmount("42000000000000000000");
+    expect(client.formatStakingAmount(weiAmount)).toBe("42 GEN");
+  });
+});

package/vitest.config.ts

@@ -5,6 +5,7 @@ export default defineConfig({
   test: {
     globals: true,
     environment: "node",
+    exclude: ["node_modules/**", "tests/smoke.test.ts"],
     coverage: {
       reporter: ["text", "json", "html"],
       exclude: ["node_modules/"],

package/vitest.smoke.config.ts

@@ -0,0 +1,16 @@
+import {defineConfig} from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/smoke.test.ts"],
+    testTimeout: 30_000,
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+});