genlayer-js 0.18.10 → 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,59 +0,0 @@
-// tests/smoke.test.ts
-// Basic smoke tests to verify testnet chain configuration and connectivity
-import {describe, it, expect} from "vitest";
-import {testnetAsimov} from "@/chains/testnetAsimov";
-import {createPublicClient, http} from "viem";
-
-describe("Testnet Asimov Chain Config", () => {
-  it("should have valid RPC URL", () => {
-    const rpcUrl = testnetAsimov.rpcUrls.default.http[0];
-    expect(rpcUrl).toBe("https://zksync-os-testnet-genlayer.zksync.dev");
-  });
-
-  it("should have valid WebSocket URL", () => {
-    const wsUrl = testnetAsimov.rpcUrls.default.webSocket?.[0];
-    expect(wsUrl).toBe("wss://zksync-os-testnet-alpha.zksync.dev/ws");
-  });
-
-  it("should have consensus main contract address", () => {
-    expect(testnetAsimov.consensusMainContract?.address).toBe(
-      "0x6CAFF6769d70824745AD895663409DC70aB5B28E",
-    );
-  });
-
-  it("should have consensus data contract address", () => {
-    expect(testnetAsimov.consensusDataContract?.address).toBe(
-      "0x0D9d1d74d72Fa5eB94bcf746C8FCcb312a722c9B",
-    );
-  });
-
-  it("should have staking contract address", () => {
-    expect(testnetAsimov.stakingContract?.address).toBe(
-      "0x63Fa5E0bb10fb6fA98F44726C5518223F767687A",
-    );
-  });
-
-  it("should have correct chain ID", () => {
-    expect(testnetAsimov.id).toBe(0x107d);
-  });
-});
-
-describe("Testnet Asimov RPC Connectivity", () => {
-  it("should connect and 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);
-  }, 15000);
-
-  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);
-  }, 15000);
-});

package/tests/transactions.test.ts

@@ -1,142 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { TransactionStatus, DECIDED_STATES, isDecidedState } from "../src/types/transactions";
-import { receiptActions } from "../src/transactions/actions";
-import { localnet } from "../src/chains/localnet";
-
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-
-describe("DECIDED_STATES constant", () => {
-  it("should contain all expected decided states", () => {
-    const expectedStates = [
-      TransactionStatus.ACCEPTED,
-      TransactionStatus.UNDETERMINED,
-      TransactionStatus.LEADER_TIMEOUT,
-      TransactionStatus.VALIDATORS_TIMEOUT,
-      TransactionStatus.CANCELED,
-      TransactionStatus.FINALIZED
-    ];
-    
-    expect(DECIDED_STATES).toEqual(expectedStates);
-  });
-});
-
-describe("isDecidedState utility function", () => {
-  it("should return true for all decided states", () => {
-    const decidedStatusNumbers = ["5", "6", "13", "12", "8", "7"]; // ACCEPTED, UNDETERMINED, LEADER_TIMEOUT, VALIDATORS_TIMEOUT, CANCELED, FINALIZED
-    
-    decidedStatusNumbers.forEach(statusNum => {
-      expect(isDecidedState(statusNum)).toBe(true);
-    });
-  });
-
-  it("should return false for non-decided states", () => {
-    const nonDecidedStatusNumbers = ["0", "1", "2", "3", "4", "9", "10", "11"]; // UNINITIALIZED, PENDING, PROPOSING, COMMITTING, REVEALING, APPEAL_REVEALING, APPEAL_COMMITTING, READY_TO_FINALIZE
-    
-    nonDecidedStatusNumbers.forEach(statusNum => {
-      expect(isDecidedState(statusNum)).toBe(false);
-    });
-  });
-
-  it("should return false for invalid statuses", () => {
-    const invalidStatuses = ["999", "invalid", ""];
-    
-    invalidStatuses.forEach(status => {
-      expect(isDecidedState(status)).toBe(false);
-    });
-  });
-});
-
-describe("waitForTransactionReceipt with DECIDED_STATES", () => {
-  beforeEach(() => {
-    mockFetch.mockReset();
-  });
-
-  it("should accept all decided states when waiting for ACCEPTED", async () => {
-    const decidedStatusNumbers = ["5", "6", "13", "12", "8", "7"]; // All decided states
-    
-    for (const statusNum of decidedStatusNumbers) {
-      const mockTransaction = {
-        hash: "0x4b8037744adab7ea8335b4f839979d20031d83a8ccdf706e0ae61312930335f6",
-        status: statusNum,
-        from_address: "0x123",
-        to_address: "0x456",
-        value: "0",
-        gaslimit: "1000000",
-        nonce: "1",
-        created_at: "2023-01-01T00:00:00Z",
-      };
-
-      const mockClient = {
-        chain: localnet,
-        getTransaction: vi.fn().mockResolvedValue(mockTransaction)
-      };
-
-      const mockPublicClient = {} as any;
-
-      const actions = receiptActions(mockClient as any, mockPublicClient);
-      const result = await actions.waitForTransactionReceipt({
-        hash: "0x4b8037744adab7ea8335b4f839979d20031d83a8ccdf706e0ae61312930335f6" as any,
-        status: TransactionStatus.ACCEPTED,
-      });
-
-      expect(result).toEqual(mockTransaction);
-    }
-  });
-
-  it("should not affect waiting for specific non-ACCEPTED statuses", async () => {
-    const mockTransaction = {
-      hash: "0x4b8037744adab7ea8335b4f839979d20031d83a8ccdf706e0ae61312930335f6",
-      status: "7", // FINALIZED
-      from_address: "0x123",
-      to_address: "0x456",
-      value: "0",
-      gaslimit: "1000000",
-      nonce: "1",
-      created_at: "2023-01-01T00:00:00Z",
-    };
-
-    const mockClient = {
-      chain: localnet,
-      getTransaction: vi.fn().mockResolvedValue(mockTransaction)
-    };
-
-    const mockPublicClient = {} as any;
-
-    const actions = receiptActions(mockClient as any, mockPublicClient);
-    const result = await actions.waitForTransactionReceipt({
-      hash: "0x4b8037744adab7ea8335b4f839979d20031d83a8ccdf706e0ae61312930335f6" as any,
-      status: TransactionStatus.FINALIZED,
-    });
-
-    expect(result).toEqual(mockTransaction);
-  });
-
-  it("should maintain backward compatibility", async () => {
-    const mockTransaction = {
-      hash: "0x4b8037744adab7ea8335b4f839979d20031d83a8ccdf706e0ae61312930335f6",
-      status: "5", // ACCEPTED
-      from_address: "0x123",
-      to_address: "0x456",
-      value: "0",
-      gaslimit: "1000000",
-      nonce: "1",
-      created_at: "2023-01-01T00:00:00Z",
-    };
-
-    const mockClient = {
-      chain: localnet,
-      getTransaction: vi.fn().mockResolvedValue(mockTransaction)
-    };
-
-    const mockPublicClient = {} as any;
-
-    const actions = receiptActions(mockClient as any, mockPublicClient);
-    const result = await actions.waitForTransactionReceipt({
-      hash: "0x4b8037744adab7ea8335b4f839979d20031d83a8ccdf706e0ae61312930335f6" as any,
-      status: TransactionStatus.ACCEPTED,
-    });
-
-    expect(result).toEqual(mockTransaction);
-  });
-});