@tomo-inc/chains-service 0.0.23 → 0.0.25

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

@@ -0,0 +1,133 @@
+import { describe, it, expect } from "vitest";
+import {
+  isEvmChain,
+  isHexChainId,
+  isSameAddress,
+  getAllTypeChainIds,
+  getAmount,
+  decodeErc20Func,
+  createErc20TxData,
+} from "../evm/utils";
+
+describe("evm utils", () => {
+  describe("isEvmChain", () => {
+    it("should return true for EVM chain", () => {
+      const network = { platformType: "EVM" };
+      expect(isEvmChain(network)).toBe(true);
+    });
+
+    it("should return false for non-EVM chain", () => {
+      const network = { platformType: "SOLANA" };
+      expect(isEvmChain(network)).toBe(false);
+    });
+
+    it("should return false for null network", () => {
+      expect(isEvmChain(null)).toBe(false);
+    });
+
+    it("should return false for undefined network", () => {
+      expect(isEvmChain(undefined)).toBe(false);
+    });
+  });
+
+  describe("isHexChainId", () => {
+    it("should return true for valid hex chain ID", () => {
+      expect(isHexChainId("0x1")).toBe(true);
+      expect(isHexChainId("0x01")).toBe(true);
+      expect(isHexChainId("0x123abc")).toBe(true);
+    });
+
+    it("should return false for invalid hex chain ID", () => {
+      expect(isHexChainId("1")).toBe(false);
+      expect(isHexChainId("0xgh")).toBe(false);
+      expect(isHexChainId("")).toBe(false);
+    });
+  });
+
+  describe("isSameAddress", () => {
+    it("should return true for same addresses", () => {
+      const addr1 = "0x1234567890123456789012345678901234567890";
+      const addr2 = "0x1234567890123456789012345678901234567890";
+      expect(isSameAddress(addr1, addr2)).toBe(true);
+      expect(
+        isSameAddress("0xABC1234567890123456789012345678901234567", "0xabc1234567890123456789012345678901234567"),
+      ).toBe(true); // Case insensitive
+    });
+
+    it("should return false for different addresses", () => {
+      const addr1 = "0x1234567890123456789012345678901234567890";
+      const addr2 = "0x9876543210987654321098765432109876543210";
+      expect(isSameAddress(addr1, addr2)).toBe(false);
+    });
+  });
+
+  describe("getAllTypeChainIds", () => {
+    it("should convert hex chain ID to number and hex", () => {
+      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 to hex", () => {
+      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 to hex", () => {
+      const result = getAllTypeChainIds({ chainId: "56", chainType: "bsc" });
+      expect(result.chainId).toBe("56");
+      expect(result.chainIdHex).toBe("0x38");
+      expect(result.chainUid).toBe("bsc:56");
+    });
+  });
+
+  describe("getAmount", () => {
+    it("should convert hex value to ether amount", () => {
+      const result = getAmount("0x2386f26fc10000"); // 0.01 ETH in wei
+      expect(result).toBeCloseTo(0.01, 5);
+    });
+
+    it("should handle zero value", () => {
+      const result = getAmount("0x0");
+      expect(result).toBe(0);
+    });
+
+    it("should handle large values", () => {
+      const result = getAmount("0xde0b6b3a7640000"); // 1 ETH in wei
+      expect(result).toBe(1);
+    });
+  });
+
+  describe("decodeErc20Func", () => {
+    it("should decode ERC20 function data", () => {
+      // This is a transfer function call data
+      const transferData =
+        "0xa9059cbb00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002";
+      const result = decodeErc20Func(transferData as `0x${string}`);
+      expect(result.functionName).toBe("transfer");
+    });
+  });
+
+  describe("createErc20TxData", () => {
+    it("should create ERC20 transfer transaction data", () => {
+      const params = {
+        to: "0x1234567890123456789012345678901234567890",
+        amount: "100",
+      };
+      const token = {
+        address: "0xTokenAddress",
+        decimals: 18,
+      };
+
+      const result = createErc20TxData(params, token);
+
+      expect(result.to).toBe("0xTokenAddress");
+      expect(result.amount).toBe(0);
+      expect(result.data).toBeDefined();
+      expect(result.data).toMatch(/^0xa9059cbb/); // transfer function selector
+    });
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import {
+  DogecoinService,
+  EvmService,
+  SolanaService,
+  ChainServiceMap,
+  TomoWallet,
+  AccountType,
+  TxTypes,
+} from "../index";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+
+describe("chains-service index", () => {
+  describe("exports", () => {
+    it("should export all services", () => {
+      expect(DogecoinService).toBeDefined();
+      expect(EvmService).toBeDefined();
+      expect(SolanaService).toBeDefined();
+    });
+
+    it("should export ChainServiceMap", () => {
+      expect(ChainServiceMap).toBeDefined();
+      expect(ChainServiceMap[ChainTypeEnum.EVM]).toBe(EvmService);
+      expect(ChainServiceMap[ChainTypeEnum.SOLANA]).toBe(SolanaService);
+      expect(ChainServiceMap[ChainTypeEnum.DOGECOIN]).toBe(DogecoinService);
+    });
+
+    it("should export TomoWallet", () => {
+      expect(TomoWallet).toBeDefined();
+    });
+
+    it("should export AccountType enum", () => {
+      expect(AccountType).toBeDefined();
+    });
+
+    it("should export TxTypes enum", () => {
+      expect(TxTypes).toBeDefined();
+    });
+  });
+});

package/src/__tests__/services.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { EvmService } from "../evm/service";
+import { DogecoinService } from "../dogecoin/service";
+import { SolanaService } from "../solana/service";
+import { ChainTypeEnum } from "@tomo-inc/wallet-utils";
+import { IAccountInfo, TomoAppInfo } from "../types";
+import * as rpcModule from "../evm/rpc";
+
+describe("Chain Services", () => {
+  let mockAccountInfo: IAccountInfo;
+  let mockTomoAppInfo: TomoAppInfo;
+
+  beforeEach(() => {
+    mockAccountInfo = {
+      getCurrent: vi.fn().mockResolvedValue([
+        {
+          address: "0x1234567890123456789012345678901234567890",
+          publicKey: "test-public-key",
+        },
+      ]),
+      signMessage: vi.fn().mockResolvedValue("0xsignature"),
+      signTypedData: vi.fn().mockResolvedValue("0xtypedSignature"),
+    } as any;
+
+    mockTomoAppInfo = {
+      tomoStage: "dev",
+      appId: "test-app",
+      appName: "Test App",
+    };
+  });
+
+  describe("EvmService", () => {
+    it("should create instance", () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      expect(service).toBeInstanceOf(EvmService);
+      expect(service.chainType).toBe(ChainTypeEnum.EVM);
+    });
+
+    it("should get instance using singleton pattern", () => {
+      const service1 = EvmService.getInstance(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      const service2 = EvmService.getInstance(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      expect(service1).toBe(service2);
+    });
+
+    it("should get accounts", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      const accounts = await service.eth_accounts();
+      expect(accounts).toEqual(["0x1234567890123456789012345678901234567890"]);
+      expect(mockAccountInfo.getCurrent).toHaveBeenCalled();
+    });
+
+    it("should request accounts", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      const accounts = await service.eth_requestAccounts();
+      expect(accounts).toEqual(["0x1234567890123456789012345678901234567890"]);
+    });
+
+    it("should sign message", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      const signature = await service.personal_sign([
+        "0xmessage" as `0x${string}`,
+        "0x1234567890123456789012345678901234567890" as `0x${string}`,
+      ]);
+      expect(signature).toBe("0xsignature");
+      expect(mockAccountInfo.signMessage).toHaveBeenCalledWith("0xmessage");
+    });
+
+    it("should throw error when address mismatch in personal_sign", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      // Use a valid Ethereum address format (40 hex characters)
+      const differentAddress = "0x1111111111111111111111111111111111111111" as `0x${string}`;
+      await expect(service.personal_sign(["0xmessage" as `0x${string}`, differentAddress])).rejects.toThrow(
+        "address is not the current account",
+      );
+    });
+
+    it("should sign typed data", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      const typedData = {
+        domain: {},
+        types: {},
+        message: {},
+      };
+      const signature = await service.eth_signTypedData_v4([
+        "0x1234567890123456789012345678901234567890" as `0x${string}`,
+        typedData,
+      ]);
+      expect(signature).toBe("0xtypedSignature");
+      expect(mockAccountInfo.signTypedData).toHaveBeenCalledWith(typedData);
+    });
+
+    it("should throw error when address mismatch in eth_signTypedData_v4", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      const typedData = {
+        domain: {},
+        types: {},
+        message: {},
+      };
+      // Use a valid Ethereum address format (40 hex characters)
+      const differentAddress = "0x1111111111111111111111111111111111111111" as `0x${string}`;
+      await expect(service.eth_signTypedData_v4([differentAddress, typedData])).rejects.toThrow(
+        "address is not the current account",
+      );
+    });
+
+    it("should get balance", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+
+      // Mock getCurrentChain
+      const mockChain = {
+        chainId: 1,
+        rpcUrls: ["https://rpc.example.com"],
+        nativeCurrencyName: "ETH",
+        nativeCurrencySymbol: "ETH",
+        nativeCurrencyDecimals: 18,
+        name: "Ethereum",
+      };
+      vi.spyOn(service as any, "getCurrentChain").mockResolvedValue(mockChain);
+
+      // Mock getRPCClient
+      const mockRpcClient = {
+        getBalance: vi.fn().mockResolvedValue(BigInt("1000000000000000000")),
+      };
+      vi.spyOn(rpcModule, "getRPCClient").mockReturnValue({
+        rpcClient: mockRpcClient,
+      } as any);
+
+      const balance = await service.eth_getBalance([
+        "0x1234567890123456789012345678901234567890" as `0x${string}`,
+        "latest",
+      ]);
+      expect(balance).toBe("1000000000000000000");
+      expect(mockRpcClient.getBalance).toHaveBeenCalled();
+    });
+
+    it("should throw error when address mismatch in eth_getBalance", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      // Use a valid Ethereum address format (40 hex characters)
+      const differentAddress = "0x1111111111111111111111111111111111111111" as `0x${string}`;
+      await expect(service.eth_getBalance([differentAddress, "latest"])).rejects.toThrow(
+        "address is not the current account",
+      );
+    });
+
+    it("should throw error for unsupported type in eth_getBalance", async () => {
+      const service = new EvmService(ChainTypeEnum.EVM, mockAccountInfo, mockTomoAppInfo);
+      await expect(
+        service.eth_getBalance(["0x1234567890123456789012345678901234567890" as `0x${string}`, "pending" as any]),
+      ).rejects.toThrow("type is not supported");
+    });
+  });
+
+  describe("DogecoinService", () => {
+    it("should create instance", () => {
+      const service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      expect(service).toBeInstanceOf(DogecoinService);
+      expect(service.chainType).toBe(ChainTypeEnum.DOGECOIN);
+    });
+
+    it("should get instance using singleton pattern", () => {
+      const service1 = DogecoinService.getInstance(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      const service2 = DogecoinService.getInstance(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      expect(service1).toBe(service2);
+    });
+
+    it("should request accounts", async () => {
+      const service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      const accounts = await service.requestAccounts();
+      expect(accounts).toEqual(["0x1234567890123456789012345678901234567890"]);
+    });
+
+    it("should get accounts", async () => {
+      const service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      const accounts = await service.getAccounts();
+      expect(accounts).toEqual(["0x1234567890123456789012345678901234567890"]);
+    });
+
+    it("should get connection status", async () => {
+      const service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      const status = await service.getConnectionStatus();
+      expect(status.connected).toBe(true);
+      expect(status.address).toBe("0x1234567890123456789012345678901234567890");
+      expect(status.selectedWalletAddress).toBe("0x1234567890123456789012345678901234567890");
+    });
+
+    it("should throw error when address is not set in getConnectionStatus", async () => {
+      const service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      mockAccountInfo.getCurrent = vi.fn().mockResolvedValue([]);
+      await expect(service.getConnectionStatus()).rejects.toThrow("address is not set");
+    });
+
+    it("should sign message", async () => {
+      const service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      const signature = await service.signMessage({ message: "test message" });
+      expect(signature).toBe("0xsignature");
+      expect(mockAccountInfo.signMessage).toHaveBeenCalledWith("test message");
+    });
+
+    it("should throw error for unsupported message type", async () => {
+      const service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      await expect(service.signMessage({ message: "test", type: "bip322simple" })).rejects.toThrow(
+        "bip322simple not support.",
+      );
+    });
+
+    it("should request signed message", async () => {
+      const service = new DogecoinService(ChainTypeEnum.DOGECOIN, mockAccountInfo, mockTomoAppInfo);
+      const result = await service.requestSignedMessage({ message: "test message" });
+      expect(result.signedMessage).toBe("0xsignature");
+    });
+  });
+
+  describe("SolanaService", () => {
+    it("should create instance", () => {
+      const service = new SolanaService(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      expect(service).toBeInstanceOf(SolanaService);
+      expect(service.chainType).toBe(ChainTypeEnum.SOLANA);
+    });
+
+    it("should get instance using singleton pattern", () => {
+      const service1 = SolanaService.getInstance(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      const service2 = SolanaService.getInstance(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      expect(service1).toBe(service2);
+    });
+
+    it("should get current wallet account", async () => {
+      const service = new SolanaService(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      // getCurrentWalletAccount returns getCurrent() directly, which returns array
+      const account = await service.getCurrentWalletAccount();
+      expect(account).toEqual([
+        {
+          address: "0x1234567890123456789012345678901234567890",
+          publicKey: "test-public-key",
+        },
+      ]);
+    });
+
+    it("should get account", async () => {
+      // Reset mock for this test
+      mockAccountInfo.getCurrent = vi.fn().mockResolvedValue({
+        address: "0x1234567890123456789012345678901234567890",
+        publicKey: "test-public-key",
+      });
+      const service = new SolanaService(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      const account = await service.getAccount();
+      expect(account.publicKey).toBe("test-public-key");
+      expect(account.address).toBe("0x1234567890123456789012345678901234567890");
+    });
+
+    it("should sign message", async () => {
+      // Reset mock for this test
+      mockAccountInfo.getCurrent = vi.fn().mockResolvedValue({
+        address: "0x1234567890123456789012345678901234567890",
+        publicKey: "test-public-key",
+      });
+      const service = new SolanaService(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      const result = await service.signMessage({ message: "test message" });
+      expect(result.signature).toBe("0xsignature");
+      expect(result.message).toContain("test message");
+      expect(mockAccountInfo.signMessage).toHaveBeenCalledWith("test message");
+    });
+
+    it("should sign in", async () => {
+      // Reset mock for this test - signIn expects getCurrent to return an object
+      mockAccountInfo.getCurrent = vi.fn().mockResolvedValue({
+        address: "0x1234567890123456789012345678901234567890",
+        publicKey: "test-public-key",
+      });
+      const service = new SolanaService(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+
+      const result = await service.signIn({ message: "test message" });
+      expect(result.signature).toBe("0xsignature");
+      expect(result.address).toBe("0x1234567890123456789012345678901234567890");
+      expect(result.publicKey).toBe("test-public-key");
+      expect(result.signedMessage).toContain("test message");
+    });
+
+    it("should throw error for unsupported request method", async () => {
+      const service = new SolanaService(ChainTypeEnum.SOLANA, mockAccountInfo, mockTomoAppInfo);
+      await expect(service.request({ method: "unsupportedMethod", params: {} })).rejects.toThrow(
+        "unsupportedMethod in request is not supported",
+      );
+    });
+  });
+});

package/src/__tests__/solana-utils.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect } from "vitest";
+import { isAddress, txToHex, hexToTx, hexToUint8Array, decodeMetadata } from "../solana/utils";
+import { VersionedTransaction, TransactionMessage, PublicKey, Transaction } from "@solana/web3.js";
+
+describe("solana utils", () => {
+  describe("isAddress", () => {
+    it("should return true for valid Solana address", () => {
+      const validAddress = "11111111111111111111111111111111";
+      expect(isAddress(validAddress)).toBe(true);
+    });
+
+    it("should return false for invalid Solana address", () => {
+      expect(isAddress("invalid")).toBe(false);
+      expect(isAddress("")).toBe(false);
+    });
+  });
+
+  describe("txToHex", () => {
+    it("should convert VersionedTransaction to hex", () => {
+      const mockTx = new VersionedTransaction(
+        new TransactionMessage({
+          payerKey: new PublicKey("11111111111111111111111111111111"),
+          recentBlockhash: "11111111111111111111111111111111",
+          instructions: [],
+        }).compileToV0Message(),
+      );
+
+      const result = txToHex(mockTx);
+      expect(typeof result).toBe("string");
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it("should convert Transaction to hex", () => {
+      const mockTx = new Transaction();
+      // Set required fields for Transaction
+      mockTx.recentBlockhash = "11111111111111111111111111111111";
+      mockTx.feePayer = new PublicKey("11111111111111111111111111111111");
+
+      const result = txToHex(mockTx);
+      expect(typeof result).toBe("string");
+      expect(result.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("hexToTx", () => {
+    it("should convert hex to VersionedTransaction", () => {
+      // This would need actual valid transaction hex
+      // For now, we test that it attempts deserialization
+      expect(() => {
+        hexToTx("invalidhex");
+      }).toThrow();
+    });
+
+    it("should throw error for invalid hex", () => {
+      expect(() => {
+        hexToTx("invalid");
+      }).toThrow("Failed to deserialize transaction");
+    });
+  });
+
+  describe("hexToUint8Array", () => {
+    it("should convert hex string with 0x prefix to Uint8Array", () => {
+      const hex = "0x" + "a".repeat(128);
+      const result = hexToUint8Array(hex);
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(64);
+    });
+
+    it("should convert hex string without 0x prefix to Uint8Array", () => {
+      const hex = "a".repeat(128);
+      const result = hexToUint8Array(hex);
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(result.length).toBe(64);
+    });
+
+    it("should throw error for invalid signature length", () => {
+      expect(() => hexToUint8Array("0x123")).toThrow("Invalid signature length");
+      expect(() => hexToUint8Array("123")).toThrow("Invalid signature length");
+    });
+  });
+
+  describe("decodeMetadata", () => {
+    it("should decode metadata from buffer", () => {
+      // Create a mock buffer with metadata structure
+      const buffer = Buffer.alloc(200);
+      let offset = 1 + 32 + 32; // Key + UpdateAuthority + Mint
+
+      // Write name length and name
+      buffer.writeUInt32LE(4, offset);
+      offset += 4;
+      buffer.write("Test", offset);
+      offset += 4;
+
+      // Write symbol length and symbol
+      buffer.writeUInt32LE(3, offset);
+      offset += 4;
+      buffer.write("TST", offset);
+      offset += 3;
+
+      // Write URI length and URI
+      buffer.writeUInt32LE(10, offset);
+      offset += 4;
+      buffer.write("https://...", offset);
+      offset += 10;
+
+      // Write seller fee (2 bytes)
+      offset += 2;
+
+      // Write creator length (1 byte)
+      buffer[offset] = 0;
+      offset += 1;
+
+      // Write decimals (1 byte)
+      buffer[offset] = 9;
+
+      const result = decodeMetadata(buffer);
+      expect(result.name).toBe("Test");
+      expect(result.symbol).toBe("TST");
+      expect(result.decimals).toBe(9);
+    });
+
+    it("should return default values on error", () => {
+      const invalidBuffer = Buffer.from("invalid");
+      const result = decodeMetadata(invalidBuffer);
+      expect(result.name).toBe("");
+      expect(result.symbol).toBe("");
+      expect(result.uri).toBe("");
+      expect(result.decimals).toBe(0);
+    });
+  });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { waitOnly } from "../utils";
+
+describe("utils", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe("waitOnly", () => {
+    it("should resolve after specified milliseconds", async () => {
+      const ms = 1000;
+      const promise = waitOnly(ms);
+
+      vi.advanceTimersByTime(ms);
+
+      const result = await promise;
+      expect(result).toBe(ms);
+    });
+
+    it("should resolve with correct delay", async () => {
+      const ms = 500;
+      const startTime = Date.now();
+      const promise = waitOnly(ms);
+
+      vi.advanceTimersByTime(ms);
+
+      await promise;
+      // With fake timers, we just verify it resolves
+      expect(await promise).toBe(ms);
+    });
+
+    it("should handle zero delay", async () => {
+      const promise = waitOnly(0);
+      vi.advanceTimersByTime(0);
+      const result = await promise;
+      expect(result).toBe(0);
+    });
+
+    it("should handle large delay", async () => {
+      const ms = 10000;
+      const promise = waitOnly(ms);
+      vi.advanceTimersByTime(ms);
+      const result = await promise;
+      expect(result).toBe(ms);
+    });
+  });
+});