genlayer-js 0.18.11 → 0.18.12

package/src/wallet/connect.ts

@@ -1,67 +0,0 @@
-import {localnet} from "@/chains/localnet";
-import {studionet} from "@/chains/studionet";
-import {testnetAsimov} from "@/chains/testnetAsimov";
-import {GenLayerClient, GenLayerChain} from "@/types";
-import {Network} from "@/types/network";
-import {SnapSource} from "@/types/snapSource";
-import {snapID} from "@/config/snapID";
-
-const networks = {
-  localnet,
-  studionet,
-  testnetAsimov,
-};
-
-export const connect = async (
-  client: GenLayerClient<GenLayerChain>,
-  network: Network = "studionet",
-  snapSource: SnapSource = "npm",
-): Promise<void> => {
-  if (!window.ethereum) {
-    throw new Error("MetaMask is not installed.");
-  }
-  if (network === "mainnet") {
-    throw new Error(`${network} is not available yet. Please use localnet.`);
-  }
-
-  const selectedNetwork = networks[network];
-  if (!selectedNetwork) {
-    throw new Error(`Network configuration for '${network}' is not available.`);
-  }
-
-  const chainIdHex = `0x${selectedNetwork.id.toString(16)}`;
-  const chainParams = {
-    chainId: chainIdHex,
-    chainName: selectedNetwork.name,
-    rpcUrls: selectedNetwork.rpcUrls.default.http,
-    nativeCurrency: selectedNetwork.nativeCurrency,
-    blockExplorerUrls: [selectedNetwork.blockExplorers?.default.url],
-  };
-
-  const currentChainId = await window.ethereum.request({method: "eth_chainId"});
-  if (currentChainId !== chainIdHex) {
-    await window.ethereum.request({
-      method: "wallet_addEthereumChain",
-      params: [chainParams],
-    });
-    await window.ethereum.request({
-      method: "wallet_switchEthereumChain",
-      params: [{chainId: chainIdHex}],
-    });
-  }
-
-  const id = snapSource === "local" ? snapID.local : snapID.npm;
-  const installedSnaps: any = await window.ethereum.request({method: "wallet_getSnaps"});
-  const isGenLayerSnapInstalled = Object.values(installedSnaps).some((snap: any) => snap.id === id);
-
-  if (!isGenLayerSnapInstalled) {
-    await window.ethereum.request({
-      method: "wallet_requestSnaps",
-      params: {
-        [id]: {},
-      },
-    });
-  }
-
-  client.chain = selectedNetwork;
-};

package/src/wallet/metamaskClient.ts

@@ -1,50 +0,0 @@
-import { snapID } from "@/config/snapID";
-import { SnapSource } from "@/types/snapSource";
-import { MetaMaskClientResult } from "@/types/metamaskClientResult";
-
-export const metamaskClient = async (snapSource: SnapSource = "npm") => {
-  if (typeof window === "undefined" || !window.ethereum) {
-    throw new Error("MetaMask is not installed.");
-  }
-
-  const isFlask = async (): Promise<boolean> => {
-    try {
-      const clientVersion = await window.ethereum?.request({
-        method: "web3_clientVersion",
-      });
-
-      return (clientVersion as string)?.includes("flask");
-    } catch (error) {
-      console.error("Error detecting Flask:", error);
-      return false;
-    }
-  };
-
-  const installedSnaps = async (): Promise<Record<string, any>> => {
-    try {
-      return (await window.ethereum?.request({
-        method: "wallet_getSnaps",
-      })) as Record<string, any>;
-    } catch (error) {
-      console.error("Error getting installed snaps:", error);
-      return {};
-    }
-  };
-
-  const isGenLayerSnapInstalled = async (): Promise<boolean> => {
-    const id = snapSource === "local" ? snapID.local : snapID.npm;
-    const snaps = await installedSnaps();
-
-    return Object.values(snaps).some((snap: any) => snap.id === id);
-  };
-
-  const flaskDetected = await isFlask();
-  const snapsList = await installedSnaps();
-  const genLayerSnapInstalled = await isGenLayerSnapInstalled();
-
-  return {
-    isFlask: flaskDetected,
-    installedSnaps: snapsList,
-    isGenLayerSnapInstalled: genLayerSnapInstalled,
-  } as MetaMaskClientResult;
-};

package/tests/client.test-d.ts

@@ -1,67 +0,0 @@
-import {createClient} from "../src/client/client";
-import {localnet} from "@/chains/localnet";
-import {createAccount, generatePrivateKey} from "../src/accounts/account";
-import {TransactionHash, TransactionStatus} from "../src/types/transactions";
-
-test("type checks", () => {
-  const client = createClient({
-    chain: localnet,
-    account: createAccount(generatePrivateKey()),
-  });
-
-  const exampleAddress = "0x1234567890123456789012345678901234567890";
-
-  // This should fail type checking - "whatever" is not a valid filter
-  // @ts-expect-error "whatever" is not a valid filter type
-  void client.request({
-    method: "sim_getTransactionsForAddress",
-    params: [exampleAddress, "whatever"],
-  });
-
-  // This should pass type checking - "all", "to" and "from" are valid filters
-  void client.request({
-    method: "sim_getTransactionsForAddress",
-    params: [exampleAddress, "all"],
-  });
-
-  void client.request({
-    method: "sim_getTransactionsForAddress",
-    params: [exampleAddress, "to"],
-  });
-
-  void client.request({
-    method: "sim_getTransactionsForAddress",
-    params: [exampleAddress, "from"],
-  });
-
-  void client.getContractSchema(exampleAddress);
-
-  void client.getContractSchemaForCode("class SomeContract...");
-
-  void client.waitForTransactionReceipt({
-    hash: "0x1234567890123456789012345678901234567890123456789012345678901234" as TransactionHash,
-  });
-
-  void client.waitForTransactionReceipt({
-    hash: "0x1234567890123456789012345678901234567890123456789012345678901234" as TransactionHash,
-    status: TransactionStatus.FINALIZED,
-  });
-
-  void client.waitForTransactionReceipt({
-    hash: "0x1234567890123456789012345678901234567890123456789012345678901234" as TransactionHash,
-    status: TransactionStatus.FINALIZED,
-    interval: 1000,
-  });
-
-  void client.waitForTransactionReceipt({
-    hash: "0x1234567890123456789012345678901234567890123456789012345678901234" as TransactionHash,
-    status: TransactionStatus.FINALIZED,
-    interval: 1000,
-    retries: 10,
-  });
-
-  // @ts-expect-error missing hash
-  void client.waitForTransactionReceipt({
-    status: TransactionStatus.FINALIZED,
-  });
-});

package/tests/client.test.ts

@@ -1,197 +0,0 @@
-// tests/client.test.ts
-import {createClient} from "../src/client/client";
-import {localnet} from "@/chains/localnet";
-import {Address} from "../src/types/accounts";
-import {createAccount, generatePrivateKey} from "../src/accounts/account";
-import {vi} from "vitest";
-import {TransactionHashVariant} from "../src/types/transactions";
-import {zeroAddress} from "viem";
-
-// Setup fetch mock
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-
-// Store for gen_call parameters received by mockFetch
-let lastGenCallParams: any = null;
-
-describe("Client Creation", () => {
-  it("should create a client for the localnet", () => {
-    const client = createClient({chain: localnet});
-    expect(client).toBeDefined();
-    expect(client.chain).toBe(localnet);
-  });
-});
-
-describe("Client Overrides", () => {
-  beforeEach(() => {
-    mockFetch.mockReset();
-    lastGenCallParams = null; // Reset for each test
-
-    mockFetch.mockImplementation(async (url, options) => {
-      let body = {};
-      const bodyString = typeof options?.body === "string" ? options.body : null;
-
-      if (bodyString) {
-        try {
-          body = JSON.parse(bodyString);
-        } catch (e) {
-          console.error("[TESTS] mockFetch: Failed to parse bodyString:", bodyString, "Error:", e);
-          // Return a generic error if body parsing fails
-          return {
-            ok: false,
-            status: 500,
-            json: async () => ({error: {message: "mockFetch body parse error"}}),
-          };
-        }
-      }
-
-      const method = (body as any).method;
-      // console.log(`[TESTS] mockFetch called: URL=${url}, Method=${method}, Body=`, body); // Optional: keep for debugging
-
-      if (method === "sim_getConsensusContract") {
-        // console.log("[TESTS] mockFetch: Handling sim_getConsensusContract");
-        return {
-          ok: true,
-          json: async () => ({
-            result: {
-              address: "0x0000000000000000000000000000000000000001",
-              abi: [],
-            },
-          }),
-        };
-      } else if (method === "gen_call") {
-        // console.log("[TESTS] mockFetch: Handling gen_call");
-        lastGenCallParams = (body as any).params; // Store the params for gen_call
-        return {
-          ok: true,
-          json: async () => ({result: "0"}),
-        };
-      }
-
-      console.warn(`[TESTS] mockFetch: Unhandled method - URL=${url}, Method=${method}, Body=`, body);
-      return {
-        ok: false,
-        status: 404, // Not Found for unhandled methods
-        json: async () => ({error: {message: `Unexpected fetch mock call to method: ${method}`}}),
-      };
-    });
-  });
-
-  afterEach(() => {
-    // Restore any spies if they weren't restored in tests
-    vi.restoreAllMocks();
-  });
-
-  it("should default to client account if no account is provided", async () => {
-    const account = createAccount(generatePrivateKey());
-    const client = createClient({
-      chain: localnet,
-      account: account,
-    });
-
-    // const requestSpy = vi.spyOn(client, "request"); // Removed spy
-
-    const contractAddress = "0x1234567890123456789012345678901234567890";
-    await client.readContract({
-      address: contractAddress as Address,
-      functionName: "testFunction",
-      args: ["arg1", "arg2"],
-      transactionHashVariant: TransactionHashVariant.LATEST_NONFINAL,
-    });
-
-    expect(lastGenCallParams).toEqual([
-      {
-        type: "read",
-        to: contractAddress,
-        from: account.address,
-        data: expect.any(String), // The data is complex, checking type is often sufficient
-        transaction_hash_variant: TransactionHashVariant.LATEST_NONFINAL,
-      },
-    ]);
-  });
-
-  it("should override client account if account is provided", async () => {
-    const clientInternalAccount = createAccount(generatePrivateKey()); // Renamed for clarity
-    const client = createClient({
-      chain: localnet,
-      account: clientInternalAccount,
-    });
-
-    const overrideAccount = createAccount(generatePrivateKey());
-
-    // const requestSpy = vi.spyOn(client, "request"); // Removed spy
-
-    const contractAddress = "0x1234567890123456789012345678901234567890";
-    await client.readContract({
-      account: overrideAccount,
-      address: contractAddress as Address,
-      functionName: "testFunction",
-      args: ["arg1", "arg2"],
-      transactionHashVariant: TransactionHashVariant.LATEST_FINAL,
-    });
-
-    expect(lastGenCallParams).toEqual([
-      {
-        type: "read",
-        to: contractAddress,
-        from: overrideAccount.address,
-        data: expect.any(String),
-        transaction_hash_variant: TransactionHashVariant.LATEST_FINAL,
-      },
-    ]);
-  });
-
-  it("should use client account if account is an address string and no override", async () => {
-    // Clarified title
-    const accountAddressString = "0x65e03a3e916CF1dC92d3C8E8186a89CfAB0D2bc2";
-    const client = createClient({
-      chain: localnet,
-      account: accountAddressString, // Client's account is an address string
-    });
-
-    // const requestSpy = vi.spyOn(client, "request"); // Removed spy
-
-    const contractAddress = "0x1234567890123456789012345678901234567890";
-    await client.readContract({
-      address: contractAddress as Address,
-      functionName: "testFunction",
-      args: ["arg1", "arg2"],
-      // No stateStatus, no account override in this specific call to readContract
-    });
-
-    expect(lastGenCallParams).toEqual([
-      {
-        type: "read",
-        to: contractAddress,
-        from: accountAddressString, // Expecting the address string directly
-        data: expect.any(String),
-        transaction_hash_variant: TransactionHashVariant.LATEST_NONFINAL,
-      },
-    ]);
-  });
-
-  it("should use zero address when no account is provided anywhere", async () => {
-    const client = createClient({
-      chain: localnet,
-      // No account provided on client
-    });
-
-    const contractAddress = "0x1234567890123456789012345678901234567890";
-    await client.readContract({
-      // No account override either
-      address: contractAddress as Address,
-      functionName: "testFunction",
-      args: ["arg1", "arg2"],
-    });
-
-    expect(lastGenCallParams).toEqual([
-      {
-        type: "read",
-        to: contractAddress,
-        from: zeroAddress, // Should default to zero address
-        data: expect.any(String),
-        transaction_hash_variant: TransactionHashVariant.LATEST_NONFINAL,
-      },
-    ]);
-  });
-});

package/tests/smoke.test.ts

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