@tomo-inc/chains-service 0.0.23 → 0.0.25

package/src/evm/__tests__/service.test.ts

@@ -0,0 +1,535 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { EvmService } from "../service";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+import { IAccountInfo, TomoAppInfo } from "../../types";
+
+// Mock viem
+vi.mock("viem", async () => {
+  const actual = await vi.importActual("viem");
+  return {
+    ...actual,
+    createPublicClient: vi.fn(),
+    http: vi.fn(),
+    parseTransaction: vi.fn(),
+  };
+});
+
+// Mock rpc module
+vi.mock("../rpc", () => ({
+  getRPCClient: vi.fn(),
+}));
+
+describe("EvmService", () => {
+  let mockAccountInfo: IAccountInfo;
+  let mockTomoAppInfo: TomoAppInfo;
+  let service: EvmService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (EvmService as any).instance = undefined;
+
+    mockAccountInfo = {
+      getCurrent: vi.fn().mockResolvedValue([
+        {
+          address: "0x1234567890123456789012345678901234567890",
+          publicKey: "test-public-key",
+        },
+      ]),
+      signMessage: vi.fn().mockResolvedValue("0xsignature"),
+      signTypedData: vi.fn().mockResolvedValue("0xtypedSignature"),
+      signTransaction: vi.fn().mockResolvedValue("0xsignedTx"),
+    } as any;
+
+    mockTomoAppInfo = {
+      tomoStage: "dev",
+      appId: "test-app",
+      appName: "Test App",
+    };
+
+    service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+  });
+
+  describe("eth_chainId", () => {
+    it("should get chain ID", async () => {
+      const mockChain = {
+        chainId: 1,
+        rpcUrls: ["https://rpc.example.com"],
+      };
+      vi.spyOn(service as any, "getCurrentChain").mockResolvedValue(mockChain);
+
+      const chainId = await service.eth_chainId();
+      expect(chainId).toBe("0x1");
+    });
+  });
+
+  describe("getCurrentChain", () => {
+    it("should return current network via getCurrentNetwork", async () => {
+      const mockNetwork = { chainId: 1, rpcUrls: ["https://rpc.example.com"] };
+      (service as any).networks = {
+        setChainType: vi.fn(),
+        getCurrentNetwork: vi.fn().mockResolvedValue(mockNetwork),
+      };
+      const result = await (service as any).getCurrentChain();
+      expect(result).toEqual(mockNetwork);
+    });
+  });
+
+  describe("wallet_switchEthereumChain", () => {
+    it("should switch chain successfully", async () => {
+      const mockChain = {
+        chainId: 5,
+        platformType: "EVM",
+      };
+      vi.spyOn(service as any, "isChainSupported").mockResolvedValue(true);
+      (service as any).networks = {
+        setCurrentNetwork: vi.fn().mockResolvedValue(true),
+      };
+
+      const result = await service.wallet_switchEthereumChain([{ chainId: "0x5" }]);
+      expect(result).toBe(true);
+    });
+
+    it("should throw error when chain is not supported", async () => {
+      vi.spyOn(service as any, "isChainSupported").mockResolvedValue(false);
+
+      await expect(service.wallet_switchEthereumChain([{ chainId: "0x999" }])).rejects.toThrow(
+        "Chain 0x999 is not supported",
+      );
+    });
+  });
+
+  describe("isChainSupported", () => {
+    it("should return false when getNetworkByChainId returns null", async () => {
+      (service as any).networks = {
+        getNetworkByChainId: vi.fn().mockResolvedValue(null),
+      };
+      const result = await (service as any).isChainSupported("0x1");
+      expect(result).toBe(false);
+    });
+
+    it("should return false when chainInfo is not EVM", async () => {
+      (service as any).networks = {
+        getNetworkByChainId: vi.fn().mockResolvedValue({ platformType: "SOLANA" }),
+      };
+      const result = await (service as any).isChainSupported("0x1");
+      expect(result).toBe(false);
+    });
+
+    it("should return false when res.chainId is empty (covers line 90-91)", async () => {
+      (service as any).networks = { getNetworkByChainId: vi.fn() };
+      const result = await (service as any).isChainSupported("");
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("eth_getBalance", () => {
+    it("should return balance", async () => {
+      const mockRpcClient = { getBalance: vi.fn().mockResolvedValue(BigInt(1000000000000000000)) };
+      vi.spyOn(service as any, "getCurrentChain").mockResolvedValue({ rpcUrls: ["https://rpc.example.com"] });
+      const { getRPCClient } = await import("../rpc");
+      vi.mocked(getRPCClient).mockReturnValue({ rpcClient: mockRpcClient } as any);
+
+      const balance = await service.eth_getBalance(["0x1234567890123456789012345678901234567890", "latest"]);
+      expect(balance).toBeDefined();
+    });
+
+    it("should return 0 when getBalance throws", async () => {
+      const mockRpcClient = { getBalance: vi.fn().mockRejectedValue(new Error("RPC error")) };
+      vi.spyOn(service as any, "getCurrentChain").mockResolvedValue({ rpcUrls: ["https://rpc.example.com"] });
+      const { getRPCClient } = await import("../rpc");
+      vi.mocked(getRPCClient).mockReturnValue({ rpcClient: mockRpcClient } as any);
+
+      const balance = await service.eth_getBalance(["0x1234567890123456789012345678901234567890", "latest"]);
+      expect(balance).toBe("0");
+    });
+
+    it("should throw when type is not latest", async () => {
+      await expect(
+        service.eth_getBalance(["0x1234567890123456789012345678901234567890", "pending" as any]),
+      ).rejects.toThrow("type is not supported");
+    });
+  });
+
+  describe("eth_estimateGas", () => {
+    it("should estimate gas successfully", async () => {
+      const mockRpcClient = {
+        estimateGas: vi.fn().mockResolvedValue("0x5208"),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      const gas = await service.eth_estimateGas([
+        {
+          from: "0x1234567890123456789012345678901234567890",
+          to: "0x9876543210987654321098765432109876543210",
+          value: "0x1",
+          chainId: "0x1",
+        },
+      ]);
+
+      expect(gas).toBe("0x5208");
+    });
+
+    it("should throw error when address mismatch", async () => {
+      await expect(
+        service.eth_estimateGas([
+          {
+            from: "0x1111111111111111111111111111111111111111",
+            to: "0x9876543210987654321098765432109876543210",
+            value: "0x1",
+            chainId: "0x1",
+          },
+        ]),
+      ).rejects.toThrow("address is not the current account");
+    });
+
+    it("should throw error when to is not set", async () => {
+      await expect(
+        service.eth_estimateGas([
+          {
+            from: "0x1234567890123456789012345678901234567890",
+            to: undefined as any,
+            value: "0x1",
+            chainId: "0x1",
+          },
+        ]),
+      ).rejects.toThrow("to is not set");
+    });
+
+    it("should return default gas on error", async () => {
+      const mockRpcClient = {
+        estimateGas: vi.fn().mockRejectedValue(new Error("RPC Error")),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      const gas = await service.eth_estimateGas([
+        {
+          from: "0x1234567890123456789012345678901234567890",
+          to: "0x9876543210987654321098765432109876543210",
+          value: "0x1",
+          chainId: "0x1",
+        },
+      ]);
+
+      expect(gas).toBeDefined();
+    });
+  });
+
+  describe("eth_getTransactionCount", () => {
+    it("should get transaction count", async () => {
+      const mockRpcClient = {
+        getTransactionCount: vi.fn().mockResolvedValue(5),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      const nonce = await service.eth_getTransactionCount(["0x1234567890123456789012345678901234567890", "latest"]);
+      expect(nonce).toBe(5);
+    });
+
+    it("should accept pending type", async () => {
+      const mockRpcClient = {
+        getTransactionCount: vi.fn().mockResolvedValue(3),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      const nonce = await service.eth_getTransactionCount(["0x1234567890123456789012345678901234567890", "pending"]);
+      expect(nonce).toBe(3);
+    });
+
+    it("should throw error when address mismatch", async () => {
+      await expect(
+        service.eth_getTransactionCount(["0x1111111111111111111111111111111111111111", "latest"]),
+      ).rejects.toThrow("address is not the current account");
+    });
+
+    it("should throw error for unsupported type", async () => {
+      await expect(
+        service.eth_getTransactionCount(["0x1234567890123456789012345678901234567890", "earliest" as any]),
+      ).rejects.toThrow("type is not supported");
+    });
+
+    it("should throw when createPublicClient getTransactionCount fails", async () => {
+      const mockRpcClient = {
+        getTransactionCount: vi.fn().mockRejectedValue(new Error("RPC failed")),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      await expect(
+        service.eth_getTransactionCount(["0x1234567890123456789012345678901234567890", "latest"]),
+      ).rejects.toThrow("Failed to get nonce");
+    });
+  });
+
+  describe("eth_signTransaction", () => {
+    it("should sign transaction successfully", async () => {
+      const mockTx = {
+        hash: "0xtxhash",
+        from: "0x1234567890123456789012345678901234567890",
+        to: "0x9876543210987654321098765432109876543210",
+        value: BigInt(1000),
+        gas: BigInt(21000),
+        nonce: 0,
+        chainId: 1,
+      };
+
+      const { parseTransaction } = await import("viem");
+      vi.mocked(parseTransaction as any).mockReturnValue(mockTx);
+
+      const tx = await service.eth_signTransaction([
+        {
+          from: "0x1234567890123456789012345678901234567890",
+          to: "0x9876543210987654321098765432109876543210",
+          value: "0x3e8",
+          chainId: "0x1",
+          gas: "0x5208",
+          nonce: "0x0",
+        },
+      ]);
+
+      expect(tx).toBeDefined();
+      expect(mockAccountInfo.signTransaction).toHaveBeenCalled();
+    });
+
+    it("should throw error when gas is not set", async () => {
+      await expect(
+        service.eth_signTransaction([
+          {
+            from: "0x1234567890123456789012345678901234567890",
+            to: "0x9876543210987654321098765432109876543210",
+            value: "0x3e8",
+            chainId: "0x1",
+          },
+        ]),
+      ).rejects.toThrow("gas or to or chainId is not set");
+    });
+
+    it("should throw error when address mismatch", async () => {
+      await expect(
+        service.eth_signTransaction([
+          {
+            from: "0x1111111111111111111111111111111111111111",
+            to: "0x9876543210987654321098765432109876543210",
+            value: "0x3e8",
+            chainId: "0x1",
+            gas: "0x5208",
+            nonce: "0x0",
+          },
+        ]),
+      ).rejects.toThrow("from is not the current account");
+    });
+
+    it("should throw when serializedTransaction is empty", async () => {
+      mockAccountInfo.signTransaction = vi.fn().mockResolvedValue("");
+
+      await expect(
+        service.eth_signTransaction([
+          {
+            from: "0x1234567890123456789012345678901234567890",
+            to: "0x9876543210987654321098765432109876543210",
+            value: "0x3e8",
+            chainId: "0x1",
+            gas: "0x5208",
+            nonce: "0x0",
+          },
+        ]),
+      ).rejects.toThrow("eth_signTransaction error");
+    });
+
+    it("should throw on sign error", async () => {
+      mockAccountInfo.signTransaction = vi.fn().mockRejectedValue(new Error("sign failed"));
+
+      await expect(
+        service.eth_signTransaction([
+          {
+            from: "0x1234567890123456789012345678901234567890",
+            to: "0x9876543210987654321098765432109876543210",
+            value: "0x3e8",
+            chainId: "0x1",
+            gas: "0x5208",
+            nonce: "0x0",
+          },
+        ]),
+      ).rejects.toThrow("eth_signTransaction error");
+    });
+  });
+
+  describe("eth_sendRawTransaction", () => {
+    it("should send raw transaction", async () => {
+      const mockRpcClient = {
+        sendRawTransaction: vi.fn().mockResolvedValue("0xtxhash"),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      const hash = await service.eth_sendRawTransaction(["0xsignedTx"]);
+      expect(hash).toBe("0xtxhash");
+    });
+
+    it("should send raw transaction with custom rpcUrl", async () => {
+      const mockRpcClient = {
+        sendRawTransaction: vi.fn().mockResolvedValue("0xtxhash"),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      const hash = await service.eth_sendRawTransaction(["0xsignedTx"], "https://rpc.example.com" as any);
+      expect(hash).toBe("0xtxhash");
+    });
+
+    it("should throw when sendRawTransaction fails", async () => {
+      const mockRpcClient = {
+        sendRawTransaction: vi.fn().mockRejectedValue(new Error("reverted")),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      await expect(service.eth_sendRawTransaction(["0xsignedTx"])).rejects.toThrow("reverted");
+    });
+  });
+
+  describe("getTransaction", () => {
+    it("should get transaction", async () => {
+      const mockTx = {
+        hash: "0xtxhash",
+        from: "0x1234567890123456789012345678901234567890",
+        to: "0x9876543210987654321098765432109876543210",
+        value: BigInt(1000),
+      };
+      const mockRpcClient = {
+        getTransaction: vi.fn().mockResolvedValue(mockTx),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      const tx = await service.getTransaction("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234");
+      expect(tx).toEqual(mockTx);
+    });
+
+    it("should throw error for invalid hash", async () => {
+      await expect(service.getTransaction("invalid" as any)).rejects.toThrow("txId is not valid");
+    });
+
+    it("should throw when getTransaction RPC fails", async () => {
+      const mockRpcClient = {
+        getTransaction: vi.fn().mockRejectedValue(new Error("tx not found")),
+      };
+      vi.spyOn(service as any, "createPublicClient").mockResolvedValue(mockRpcClient);
+
+      await expect(
+        service.getTransaction("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234"),
+      ).rejects.toThrow("tx not found");
+    });
+  });
+
+  describe("createPublicClient", () => {
+    it("should use rpcUrl when provided", async () => {
+      const { createPublicClient, http } = await import("viem");
+      const client = await (service as any).createPublicClient({ rpcUrl: "https://custom.rpc.com" });
+      expect(createPublicClient).toHaveBeenCalled();
+      expect(http).toHaveBeenCalledWith("https://custom.rpc.com");
+    });
+
+    it("should use chainId to get rpcUrl when rpcUrl not provided", async () => {
+      (service as any).networks = {
+        setChainType: vi.fn(),
+        getNetworkByChainId: vi.fn().mockResolvedValue({ rpcUrls: ["https://chain.rpc.com"] }),
+      };
+      const { createPublicClient, http } = await import("viem");
+      await (service as any).createPublicClient({ chainId: "1" });
+      expect(http).toHaveBeenCalledWith("https://chain.rpc.com");
+    });
+
+    it("should use getCurrentChain when neither rpcUrl nor chainId provided", async () => {
+      vi.spyOn(service as any, "getCurrentChain").mockResolvedValue({ rpcUrls: ["https://current.rpc.com"] });
+      const { http } = await import("viem");
+      await (service as any).createPublicClient({});
+      expect(http).toHaveBeenCalledWith("https://current.rpc.com");
+    });
+
+    it("should throw when rpcUrl is not set", async () => {
+      vi.spyOn(service as any, "getCurrentChain").mockResolvedValue({ rpcUrls: [] });
+      await expect((service as any).createPublicClient({})).rejects.toThrow("rpcUrl is not set");
+    });
+  });
+
+  describe("_queryGasInfo", () => {
+    it("should query gas info successfully", async () => {
+      const mockGasInfo = {
+        baseFee: 1000000000,
+        gasLimit: 21000,
+        priorityFeeLow: 1000000000,
+        priorityFeeMedium: 1500000000,
+        priorityFeeHigh: 2000000000,
+      };
+      (service as any).transactions = {
+        queryGasInfo: vi.fn().mockResolvedValue({
+          success: true,
+          data: mockGasInfo,
+        }),
+      };
+      (service as any).networks = {
+        getNetworkByChainId: vi.fn().mockResolvedValue({
+          nativeCurrency: { decimals: 18 },
+        }),
+      };
+
+      const result = await service._queryGasInfo({
+        from: "0x1234567890123456789012345678901234567890",
+        to: "0x9876543210987654321098765432109876543210",
+        amount: 1,
+        chainId: "1",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.fees).toBeDefined();
+      expect(result.gasFee).toBeDefined();
+    });
+
+    it("should return default gas fee on error", async () => {
+      (service as any).transactions = {
+        queryGasInfo: vi.fn().mockResolvedValue({
+          success: false,
+          message: "Error",
+        }),
+      };
+
+      const result = await service._queryGasInfo({
+        from: "0x1234567890123456789012345678901234567890",
+        to: "0x9876543210987654321098765432109876543210",
+        amount: 1,
+        chainId: "1",
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.gasFee).toBeDefined();
+    });
+
+    it("should use tokenAddress and createErc20TxData when tokenAddress is provided", async () => {
+      const mockGasInfo = {
+        baseFee: 1000000000,
+        gasLimit: 21000,
+        priorityFeeLow: 1000000000,
+        priorityFeeMedium: 1500000000,
+        priorityFeeHigh: 2000000000,
+      };
+      (service as any).transactions = {
+        queryGasInfo: vi.fn().mockResolvedValue({
+          success: true,
+          data: mockGasInfo,
+        }),
+      };
+      (service as any).networks = {
+        getNetworkByChainId: vi.fn().mockResolvedValue({
+          nativeCurrency: { decimals: 18 },
+        }),
+      };
+
+      const result = await service._queryGasInfo({
+        from: "0x1234567890123456789012345678901234567890",
+        to: "0x9876543210987654321098765432109876543210",
+        amount: 100,
+        chainId: "1",
+        tokenAddress: "0xToken12345678901234567890123456789012",
+        decimals: 18,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.fees).toBeDefined();
+    });
+  });
+});

package/src/evm/__tests__/utils.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect } from "vitest";
+import {
+  isEvmChain,
+  isHexChainId,
+  isSameAddress,
+  getAllTypeChainIds,
+  getAmount,
+  decodeErc20Func,
+  createErc20TxData,
+  buildSubmitTxParams,
+} from "../utils";
+import { encodeFunctionData, erc20Abi } from "viem";
+
+describe("evm/utils", () => {
+  describe("isEvmChain", () => {
+    it("should return true for EVM chain", () => {
+      expect(isEvmChain({ platformType: "EVM" })).toBe(true);
+    });
+
+    it("should return false for non-EVM chain", () => {
+      expect(isEvmChain({ platformType: "SOLANA" })).toBe(false);
+    });
+
+    it("should return false for null", () => {
+      expect(isEvmChain(null)).toBe(false);
+    });
+
+    it("should return false for undefined", () => {
+      expect(isEvmChain(undefined)).toBe(false);
+    });
+  });
+
+  describe("isHexChainId", () => {
+    it("should return true for hex chain ID", () => {
+      expect(isHexChainId("0x1")).toBe(true);
+    });
+
+    it("should return false for non-hex chain ID", () => {
+      expect(isHexChainId("1")).toBe(false);
+    });
+  });
+
+  describe("isSameAddress", () => {
+    it("should return true for same address", () => {
+      expect(
+        isSameAddress("0x1234567890123456789012345678901234567890", "0x1234567890123456789012345678901234567890"),
+      ).toBe(true);
+    });
+
+    it("should return false for different addresses", () => {
+      expect(
+        isSameAddress("0x1234567890123456789012345678901234567890", "0x9876543210987654321098765432109876543210"),
+      ).toBe(false);
+    });
+  });
+
+  describe("getAllTypeChainIds", () => {
+    it("should convert hex chain ID", () => {
+      const result = getAllTypeChainIds({ chainId: "0x1", chainType: "evm" });
+      expect(result.chainId).toBe("1");
+      expect(result.chainIdHex).toBe("0x1");
+      expect(result.chainUid).toBe("evm:1");
+    });
+
+    it("should convert number chain ID", () => {
+      const result = getAllTypeChainIds({ chainId: 1, chainType: "evm" });
+      expect(result.chainId).toBe("1");
+      expect(result.chainIdHex).toBe("0x1");
+      expect(result.chainUid).toBe("evm:1");
+    });
+
+    it("should convert string number chain ID", () => {
+      const result = getAllTypeChainIds({ chainId: "5", chainType: "evm" });
+      expect(result.chainId).toBe("5");
+      expect(result.chainIdHex).toBe("0x5");
+      expect(result.chainUid).toBe("evm:5");
+    });
+  });
+
+  describe("getAmount", () => {
+    it("should convert hex value to amount", () => {
+      const amount = getAmount("0xde0b6b3a7640000"); // 1 ETH in hex
+      expect(amount).toBeCloseTo(1, 5);
+    });
+
+    it("should handle zero value", () => {
+      const amount = getAmount("0x0");
+      expect(amount).toBe(0);
+    });
+  });
+
+  describe("decodeErc20Func", () => {
+    it("should decode ERC20 transfer function", () => {
+      const transferData = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "transfer",
+        args: ["0x1234567890123456789012345678901234567890", BigInt(1000)],
+      });
+
+      const decoded = decodeErc20Func(transferData);
+      expect(decoded.functionName).toBe("transfer");
+    });
+  });
+
+  describe("createErc20TxData", () => {
+    it("should create ERC20 transaction data", () => {
+      const params = {
+        to: "0x9876543210987654321098765432109876543210",
+        amount: 1000,
+      };
+
+      const token = {
+        address: "0xTokenAddress1234567890123456789012345678",
+        decimals: 18,
+      };
+
+      const result = createErc20TxData(params, token);
+      expect(result.to).toBe(token.address);
+      expect(result.amount).toBe(0);
+      expect(result.data).toBeDefined();
+    });
+  });
+
+  describe("buildSubmitTxParams", () => {
+    it("should use 0 for fromAmount/toAmount when params.amount is missing", async () => {
+      const params = {
+        txParams: { maxFeePerGas: 1n, gasLimit: 21000n },
+        network: { chainIndex: 1 },
+        tx: {},
+        serializedTransaction: "0x",
+        from: "0xFrom",
+        to: "0xTo",
+        tokenAddress: "0xToken",
+      };
+      const result = await buildSubmitTxParams(params);
+      expect(result.fromAmount).toBe("0");
+      expect(result.toAmount).toBe("0");
+    });
+
+    it("should use params.amount when provided", async () => {
+      const params = {
+        amount: 100,
+        txParams: { maxFeePerGas: 1n, gasLimit: 21000n },
+        network: { chainIndex: 1 },
+        tx: {},
+        serializedTransaction: "0x",
+        from: "0xFrom",
+        to: "0xTo",
+        tokenAddress: "0xToken",
+      };
+      const result = await buildSubmitTxParams(params);
+      expect(result.fromAmount).toBe("100");
+      expect(result.toAmount).toBe("100");
+    });
+
+    it("should use gasLimit when maxFeePerGas is absent (covers line 68 branch)", async () => {
+      const params = {
+        txParams: { gasLimit: 100000n },
+        network: { chainIndex: 1 },
+        tx: {},
+        serializedTransaction: "0x",
+        from: "0xFrom",
+        to: "0xTo",
+        tokenAddress: "0xToken",
+      };
+      const result = await buildSubmitTxParams(params);
+      expect(result.estimatedGas).toBe(100000n);
+    });
+  });
+});