@tomo-inc/wallet-adaptor-base 0.0.19 → 0.0.21

package/src/__tests__/wallet-api.test.ts

@@ -0,0 +1,1755 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { connect, disconnect, connectMobile } from "../wallet-api/connect";
+import { getBalance } from "../wallet-api/balance";
+import { switchChain, addChain } from "../wallet-api/chain";
+import { signInWithWallet } from "../wallet-api/sign-in";
+import { signMessage } from "../wallet-api/sign-message";
+import { WalletOptions, ConnectParams, WalletInfo } from "../type";
+
+
+// Mock Solana Connection
+vi.mock("@solana/web3.js", () => {
+  const mockGetMultipleAccountsInfo = vi.fn().mockResolvedValue([
+    {
+      lamports: 1000000,
+    },
+  ]);
+
+  // Mock PublicKey to accept any string and return it
+  class MockPublicKey {
+    constructor(public address: string) {}
+    toString() {
+      return this.address;
+    }
+    toBase58() {
+      return this.address;
+    }
+  }
+
+  // Mock Connection as a class constructor
+  class MockConnection {
+    constructor(public rpcUrl: string) {}
+    getMultipleAccountsInfo = mockGetMultipleAccountsInfo;
+  }
+
+  return {
+    Connection: MockConnection,
+    PublicKey: MockPublicKey,
+  };
+});
+
+const mockGetAccountResource = vi.hoisted(() =>
+  vi.fn().mockResolvedValue({ coin: { value: "1000000" } }),
+);
+
+const mockCreateWalletConnectEVMProvider = vi.hoisted(() => vi.fn());
+const mockOpenUri = vi.hoisted(() => vi.fn());
+const mockIsAndroid = vi.hoisted(() => vi.fn(() => false));
+const mockIsIOS = vi.hoisted(() => vi.fn(() => false));
+const mockIsMobile = vi.hoisted(() => vi.fn(() => false));
+vi.mock("../wallets/wallet-walletconnect", () => ({
+  createWalletConnectEVMProvider: mockCreateWalletConnectEVMProvider,
+}));
+vi.mock("utils/browsers", () => ({ openUri: mockOpenUri }));
+vi.mock("../utils/isMobile", () => ({
+  isMobile: mockIsMobile,
+  isAndroid: mockIsAndroid,
+  isIOS: mockIsIOS,
+}));
+vi.mock("utils/isMobile", () => ({
+  isMobile: mockIsMobile,
+  isAndroid: mockIsAndroid,
+  isIOS: mockIsIOS,
+}));
+
+// Mock Aptos SDK
+vi.mock("@aptos-labs/ts-sdk", () => {
+  // Mock AptosConfig as a class constructor
+  class MockAptosConfig {
+    constructor(public config: any) {}
+  }
+
+  // Mock Aptos as a class constructor
+  class MockAptos {
+    getAccountResource = mockGetAccountResource;
+  }
+
+  return {
+    Aptos: MockAptos,
+    AptosConfig: MockAptosConfig,
+    Network: {
+      MAINNET: "mainnet",
+      TESTNET: "testnet",
+      DEVNET: "devnet",
+    },
+  };
+});
+
+describe("Wallet API", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Mock window object
+    global.window = {
+      ...global.window,
+      ethereum: undefined,
+    } as any;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("connect", () => {
+    it("should throw error when provider is not provided", async () => {
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: undefined,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      await expect(connect(connectParams, walletOptions)).rejects.toThrow("Provider is required");
+    });
+
+    it("should call connectMobile when isMobile and no provider and uuid not walletConnect", async () => {
+      mockIsMobile.mockReturnValueOnce(true);
+      const mockMobileProvider = { request: vi.fn().mockResolvedValue("0x1") };
+      mockCreateWalletConnectEVMProvider.mockReturnValue({
+        getProvider: vi.fn().mockResolvedValue(mockMobileProvider),
+        connectUri: "wc://x",
+        connect: vi.fn().mockResolvedValue(["0xmobile-from-connect"]),
+      });
+      const getUri = vi.fn().mockResolvedValue("phantom://wc");
+      const result = await connect(
+        { useWalletConnect: true, dappLink: "https://app.com" },
+        {
+          chainType: "evm",
+          walletInfo: { uuid: "phantom", mobile: { getUri }, links: {} } as WalletInfo,
+        },
+      );
+      expect(result.address).toBe("0xmobile-from-connect");
+      expect(result.chainId).toBe("0x1");
+      expect(result.provider).toBe(mockMobileProvider);
+    });
+
+    it("should throw error when chainType is not provided", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: undefined,
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      await expect(connect(connectParams, walletOptions)).rejects.toThrow("Chain type is required");
+    });
+
+    it("should use getProvider when provider has no request (wagmi-style)", async () => {
+      const innerProvider = {
+        request: vi.fn().mockImplementation((params: any) => {
+          if (params.method === "eth_requestAccounts") return Promise.resolve(["0xwagmi-address"]);
+          if (params.method === "eth_chainId") return Promise.resolve("0x1");
+          return Promise.resolve(null);
+        }),
+      };
+      const getProviderFn = vi.fn().mockResolvedValue(innerProvider);
+      const mockProvider = { getProvider: getProviderFn };
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+      };
+      await expect(connect({}, walletOptions)).rejects.toThrow();
+      expect(getProviderFn).toHaveBeenCalled();
+      expect(innerProvider.request).toHaveBeenCalledWith({ method: "eth_requestAccounts" });
+    });
+
+    it("should connect EVM wallet", async () => {
+      const mockProvider = {
+        request: vi.fn().mockImplementation((params: any) => {
+          if (params.method === "eth_requestAccounts") {
+            return Promise.resolve(["0x1234567890123456789012345678901234567890"]);
+          }
+          if (params.method === "eth_chainId") {
+            return Promise.resolve("0x1");
+          }
+          return Promise.resolve(null);
+        }),
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      const result = await connect(connectParams, walletOptions);
+
+      expect(result.address).toBe("0x1234567890123456789012345678901234567890");
+      expect(result.chainId).toBe("0x1");
+      expect(mockProvider.request).toHaveBeenCalledWith({ method: "eth_requestAccounts" });
+      expect(mockProvider.request).toHaveBeenCalledWith({ method: "eth_chainId" });
+    });
+
+    it("should connect Solana wallet with connect method", async () => {
+      const mockProvider = {
+        connect: vi.fn().mockResolvedValue({
+          publicKey: {
+            toString: () => "SolanaPublicKey123",
+          },
+        }),
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      const result = await connect(connectParams, walletOptions);
+
+      expect(result.address).toBe("SolanaPublicKey123");
+      expect(result.network).toBe("mainnet-beta");
+      expect(mockProvider.connect).toHaveBeenCalled();
+    });
+
+    it("should connect Solana wallet with request method", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue({
+          publicKey: {
+            toString: () => "SolanaPublicKey456",
+          },
+        }),
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      const result = await connect(connectParams, walletOptions);
+
+      expect(result.address).toBe("SolanaPublicKey456");
+      expect(result.network).toBe("mainnet-beta");
+      expect(mockProvider.request).toHaveBeenCalledWith({ method: "connect" });
+    });
+
+    it("should connect Solana wallet with standard:connect", async () => {
+      const mockProvider = {
+        "standard:connect": {
+          connect: vi.fn().mockResolvedValue({
+            accounts: [
+              {
+                address: "SolanaStandardAddress",
+              },
+            ],
+          }),
+        },
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      const result = await connect(connectParams, walletOptions);
+
+      expect(result.address).toBe("SolanaStandardAddress");
+      expect(result.network).toBe("mainnet-beta");
+    });
+
+    it("should connect Aptos wallet with connect method", async () => {
+      const mockProvider = {
+        connect: vi.fn().mockResolvedValue(undefined),
+        account: vi.fn().mockResolvedValue({
+          address: "0xaptos123",
+        }),
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      const result = await connect(connectParams, walletOptions);
+
+      expect(result.address).toBe("0xaptos123");
+      expect(result.network).toBe("mainnet");
+      expect(mockProvider.connect).toHaveBeenCalled();
+      expect(mockProvider.account).toHaveBeenCalled();
+    });
+
+    it("should connect Aptos wallet with request method", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue(undefined),
+        account: vi.fn().mockResolvedValue({ address: "0xaptos-req" }),
+      };
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+      };
+      const result = await connect({}, walletOptions);
+      expect(result.address).toBe("0xaptos-req");
+      expect(mockProvider.request).toHaveBeenCalledWith({ method: "connect" });
+    });
+
+    it("should connect Aptos wallet with aptos:connect", async () => {
+      const mockProvider = {
+        "aptos:connect": {
+          connect: vi.fn().mockResolvedValue(undefined),
+        },
+        "aptos:account": {
+          account: vi.fn().mockResolvedValue({
+            address: {
+              data: new Uint8Array([
+                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+                29, 30, 31, 32,
+              ]),
+            },
+          }),
+        },
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      const result = await connect(connectParams, walletOptions);
+
+      expect(result.address).toMatch(/^0x[0-9a-f]{64}$/);
+      expect(result.network).toBe("mainnet");
+    });
+
+    it("should connect Dogecoin wallet with connect method", async () => {
+      const mockProvider = {
+        connect: vi.fn().mockResolvedValue({
+          address: "DogeAddress123",
+        }),
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      const result = await connect(connectParams, walletOptions);
+
+      expect(result.address).toBe("DogeAddress123");
+      expect(mockProvider.connect).toHaveBeenCalled();
+    });
+
+    it("should connect Dogecoin wallet with requestAccounts method", async () => {
+      const mockProvider = {
+        requestAccounts: vi.fn().mockResolvedValue(["DogeAddress456"]),
+      };
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      const result = await connect(connectParams, walletOptions);
+
+      expect(result.address).toBe("DogeAddress456");
+      expect(mockProvider.requestAccounts).toHaveBeenCalled();
+    });
+
+    it("should throw error for unsupported Dogecoin connect", async () => {
+      const mockProvider = {};
+
+      const walletOptions: Omit<WalletOptions, "account"> = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+      };
+
+      const connectParams: ConnectParams = {};
+
+      await expect(connect(connectParams, walletOptions)).rejects.toThrow("connect not supported in dogecoin");
+    });
+  });
+
+  describe("disconnect", () => {
+    it("should throw error when provider is not provided", async () => {
+      const walletOptions: WalletOptions = {
+        provider: undefined,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(disconnect(walletOptions)).rejects.toThrow("Provider is required");
+    });
+
+    it("should throw error when chainType is not provided", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: undefined,
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(disconnect(walletOptions)).rejects.toThrow("chainType is required");
+    });
+
+    it("should disconnect EVM wallet", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue(true),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      const result = await disconnect(walletOptions);
+
+      expect(mockProvider.request).toHaveBeenCalledWith({ method: "wallet_revokePermissions" });
+      expect(result).toBe(false);
+    });
+
+    it("should disconnect Solana wallet with disconnect method", async () => {
+      const mockProvider = {
+        disconnect: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "SolanaAddress",
+          chainId: "",
+        },
+      };
+
+      const result = await disconnect(walletOptions);
+
+      expect(result).toBe(true);
+      expect(mockProvider.disconnect).toHaveBeenCalled();
+    });
+
+    it("should disconnect Solana wallet with standard:disconnect", async () => {
+      const mockProvider = {
+        "standard:disconnect": {
+          disconnect: vi.fn().mockResolvedValue(undefined),
+        },
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "SolanaAddress",
+          chainId: "",
+        },
+      };
+
+      const result = await disconnect(walletOptions);
+
+      expect(result).toBe(true);
+    });
+
+    it("should disconnect Aptos wallet with disconnect method", async () => {
+      const mockProvider = {
+        disconnect: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0xaptos",
+          chainId: "",
+        },
+      };
+
+      const result = await disconnect(walletOptions);
+
+      expect(result).toBe(true);
+      expect(mockProvider.disconnect).toHaveBeenCalled();
+    });
+
+    it("should disconnect Aptos wallet with aptos:disconnect", async () => {
+      const mockProvider = {
+        "aptos:disconnect": {
+          disconnect: vi.fn().mockResolvedValue(undefined),
+        },
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0xaptos",
+          chainId: "",
+        },
+      };
+
+      const result = await disconnect(walletOptions);
+
+      expect(result).toBe(true);
+    });
+
+    it("should disconnect Dogecoin wallet", async () => {
+      const mockProvider = {
+        disconnect: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "DogeAddress",
+          chainId: "",
+        },
+      };
+
+      const result = await disconnect(walletOptions);
+
+      expect(result).toBe(true);
+      expect(mockProvider.disconnect).toHaveBeenCalled();
+    });
+
+    it("should return true for Dogecoin even without disconnect method", async () => {
+      const mockProvider = {};
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "DogeAddress",
+          chainId: "",
+        },
+      };
+
+      const result = await disconnect(walletOptions);
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("connectMobile", () => {
+    it("should resolve with address and chainId when useWalletConnect and mobile.getUri returns uri", async () => {
+      const mockMobileProvider = {
+        request: vi.fn().mockResolvedValue("0x1"),
+      };
+      mockCreateWalletConnectEVMProvider.mockReturnValue({
+        getProvider: vi.fn().mockResolvedValue(mockMobileProvider),
+        connectUri: "wc://test-uri",
+        connect: vi.fn().mockResolvedValue(["0xmobile-addr"]),
+      });
+      const getUri = vi.fn().mockResolvedValue("phantom://wc");
+      const result = await connectMobile({
+        connectParams: { useWalletConnect: true, dappLink: "https://app.com" },
+        walletOptions: {
+          walletInfo: { uuid: "phantom", mobile: { getUri }, links: {} } as WalletInfo,
+          chainType: "evm",
+        },
+      });
+      expect((result as any).address).toBe("0xmobile-addr");
+      expect((result as any).chainId).toBe("0x1");
+      expect(getUri).toHaveBeenCalledWith("wc://test-uri");
+      expect(mockOpenUri).toHaveBeenCalledWith("phantom://wc");
+    });
+
+    it("should resolve with empty address when useWalletConnect but mobile.getUri returns null", async () => {
+      mockCreateWalletConnectEVMProvider.mockReturnValue({
+        getProvider: vi.fn().mockResolvedValue({ request: vi.fn() }),
+        connectUri: "wc://x",
+        connect: vi.fn(),
+      });
+      const result = await connectMobile({
+        connectParams: { useWalletConnect: true },
+        walletOptions: {
+          walletInfo: { uuid: "wc", mobile: { getUri: vi.fn().mockResolvedValue(null) }, links: {} } as WalletInfo,
+          chainType: "evm",
+        },
+      });
+      expect((result as any).address).toBe("");
+      expect((result as any).chainId).toBe("");
+    });
+
+    it("should reject when connectWithWalletConnect getProvider or connect fails", async () => {
+      mockCreateWalletConnectEVMProvider.mockReturnValue({
+        getProvider: vi.fn().mockRejectedValue(new Error("WC init failed")),
+        connectUri: "wc://x",
+        connect: vi.fn(),
+      });
+      const getUri = vi.fn().mockResolvedValue("wc://link");
+      await expect(
+        connectMobile({
+          connectParams: { useWalletConnect: true },
+          walletOptions: {
+            walletInfo: { uuid: "phantom", mobile: { getUri }, links: {} } as WalletInfo,
+            chainType: "evm",
+          },
+        }),
+      ).rejects.toThrow("WC init failed");
+    });
+
+    it("should not call openUri when uuid is walletConnect", async () => {
+      mockOpenUri.mockClear();
+      const mockMobileProvider = { request: vi.fn().mockResolvedValue("0x1") };
+      mockCreateWalletConnectEVMProvider.mockReturnValue({
+        getProvider: vi.fn().mockResolvedValue(mockMobileProvider),
+        connectUri: "wc://uri",
+        connect: vi.fn().mockResolvedValue(["0xaddr"]),
+      });
+      const getUri = vi.fn().mockResolvedValue("wc://link");
+      await connectMobile({
+        connectParams: { useWalletConnect: true },
+        walletOptions: {
+          walletInfo: { uuid: "walletConnect", mobile: { getUri }, links: {} } as WalletInfo,
+          chainType: "evm",
+        },
+      });
+      expect(getUri).toHaveBeenCalledWith("wc://uri");
+      expect(mockOpenUri).not.toHaveBeenCalled();
+    });
+
+    it("should use connectWithWalletConnect when useWalletConnect false but mobile.getUri exists", async () => {
+      const mockMobileProvider = { request: vi.fn().mockResolvedValue("0x1") };
+      mockCreateWalletConnectEVMProvider.mockReturnValue({
+        getProvider: vi.fn().mockResolvedValue(mockMobileProvider),
+        connectUri: "wc://y",
+        connect: vi.fn().mockResolvedValue(["0xvia-getUri"]),
+      });
+      const getUri = vi.fn().mockResolvedValue("mywallet://wc");
+      const result = await connectMobile({
+        connectParams: { useWalletConnect: false, dappLink: "https://app.com" },
+        walletOptions: {
+          walletInfo: { uuid: "mywallet", mobile: { getUri }, links: {} } as WalletInfo,
+          chainType: "evm",
+        },
+      });
+      expect((result as any).address).toBe("0xvia-getUri");
+      expect((result as any).chainId).toBe("0x1");
+    });
+
+    it("should call openUri when deeplinkTemplate.deeplink is provided", async () => {
+      mockOpenUri.mockClear();
+      connectMobile({
+        connectParams: { useWalletConnect: false, dappLink: "https://myapp.com" },
+        walletOptions: {
+          walletInfo: {
+            mobile: { deeplinkTemplate: { deeplink: "https://phantom.app/ul/{dappUrl}" } },
+            links: {},
+          } as WalletInfo,
+          chainType: "solana",
+        },
+      });
+      await vi.waitFor(() => {
+        expect(mockOpenUri).toHaveBeenCalledWith("https://phantom.app/ul/https%3A%2F%2Fmyapp.com");
+      });
+    });
+
+    it("should call openUri and throw when links have android_install", async () => {
+      mockIsAndroid.mockReturnValueOnce(true);
+      await expect(
+        connectMobile({
+          connectParams: { useWalletConnect: false },
+          walletOptions: {
+            walletInfo: {
+              name: "TestWallet",
+              mobile: {},
+              links: {
+                android_install: "https://play.google.com",
+                ios_install: "https://apps.apple.com",
+                homepage: "https://wallet.com",
+              },
+            } as WalletInfo,
+            chainType: "evm",
+          },
+        }),
+      ).rejects.toThrow("TestWallet not supported");
+      expect(mockOpenUri).toHaveBeenCalledWith("https://play.google.com");
+    });
+
+    it("should call openUri with ios_install when isIOS and links provided", async () => {
+      mockIsIOS.mockReturnValueOnce(true);
+      mockOpenUri.mockClear();
+      await expect(
+        connectMobile({
+          connectParams: { useWalletConnect: false },
+          walletOptions: {
+            walletInfo: {
+              name: "IosWallet",
+              mobile: {},
+              links: {
+                android_install: "https://play.google.com",
+                ios_install: "https://apps.apple.com",
+                homepage: "https://wallet.com",
+              },
+            } as WalletInfo,
+            chainType: "evm",
+          },
+        }),
+      ).rejects.toThrow("IosWallet not supported");
+      expect(mockOpenUri).toHaveBeenCalledWith("https://apps.apple.com");
+    });
+
+    it("should call openUri with homepage when links have no android/ios install", async () => {
+      mockIsAndroid.mockReturnValue(false);
+      mockIsIOS.mockReturnValue(false);
+      mockOpenUri.mockClear();
+      await expect(
+        connectMobile({
+          connectParams: { useWalletConnect: false },
+          walletOptions: {
+            walletInfo: {
+              name: "DesktopWallet",
+              mobile: {},
+              links: { homepage: "https://wallet.com" },
+            } as WalletInfo,
+            chainType: "evm",
+          },
+        }),
+      ).rejects.toThrow("DesktopWallet not supported");
+      expect(mockOpenUri).toHaveBeenCalledWith("https://wallet.com");
+    });
+
+    it("should throw when wallet has no supported mobile path", async () => {
+      await expect(
+        connectMobile({
+          connectParams: { useWalletConnect: false },
+          walletOptions: {
+            walletInfo: { name: "NoSupport", mobile: {}, links: {} } as WalletInfo,
+            chainType: "evm",
+          },
+        }),
+      ).rejects.toThrow("NoSupport not supported");
+    });
+  });
+
+  describe("getBalance", () => {
+    it("should throw error when provider is not provided", async () => {
+      const walletOptions: WalletOptions = {
+        provider: undefined,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(
+        getBalance(
+          {
+            chainId: "0x1",
+          },
+          walletOptions,
+        ),
+      ).rejects.toThrow("Provider is required");
+    });
+
+    it("should throw error when chainType is not provided", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: undefined,
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(
+        getBalance(
+          {
+            chainId: "0x1",
+          },
+          walletOptions,
+        ),
+      ).rejects.toThrow("Chain type is required");
+    });
+
+    it("should get EVM balance", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue("0x2386f26fc10000"), // 10000000000000000 wei
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x1234567890123456789012345678901234567890",
+          chainId: "0x1",
+        },
+      };
+
+      const result = await getBalance(
+        {
+          chainId: "0x1",
+        },
+        walletOptions,
+      );
+
+      expect(result.total).toBe(10000000000000000);
+      expect(mockProvider.request).toHaveBeenCalledWith({
+        method: "eth_getBalance",
+        params: ["0x1234567890123456789012345678901234567890", "latest"],
+      });
+    });
+
+    it("should throw error when EVM chainId mismatch", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(
+        getBalance(
+          {
+            chainId: "0x2",
+          },
+          walletOptions,
+        ),
+      ).rejects.toThrow("Chain id is required and must be current chain id");
+    });
+
+    it("should throw error for unsupported chain type", async () => {
+      const mockProvider = {};
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "unsupported" as any,
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(
+        getBalance(
+          {
+            chainId: "0x1",
+          },
+          walletOptions,
+        ),
+      ).rejects.toThrow("getBalance not supported in unsupported");
+    });
+
+    it("should get balance for Solana", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      // Use a valid Solana address (base58 encoded)
+      // System Program address: 11111111111111111111111111111111
+      const validSolanaAddress = "11111111111111111111111111111111";
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: validSolanaAddress,
+          chainId: "mainnet-beta",
+        },
+      };
+
+      const result = await getBalance(
+        {
+          chainId: "mainnet-beta",
+          address: validSolanaAddress,
+        },
+        walletOptions,
+      );
+
+      expect(result).toHaveProperty("total");
+      expect(result).toHaveProperty("tokenInfo");
+      expect(result.total).toBe(1000000);
+    });
+
+    it("should get balance for Aptos", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x1",
+          chainId: "mainnet",
+          network: "mainnet",
+        },
+      };
+
+      const result = await getBalance(
+        {
+          chainId: "mainnet",
+          address: "0x1",
+        },
+        walletOptions,
+      );
+
+      expect(result).toHaveProperty("total");
+      expect(result).toHaveProperty("tokenInfo");
+      expect(result.total).toBe(1000000);
+    });
+
+    it("should throw error when address is missing for Aptos", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "",
+          chainId: "mainnet",
+        },
+      };
+
+      await expect(
+        getBalance(
+          {
+            chainId: "mainnet",
+          },
+          walletOptions,
+        ),
+      ).rejects.toThrow("Address is required for Aptos balance query");
+    });
+
+    it("should rethrow when Aptos getAccountResource fails", async () => {
+      mockGetAccountResource.mockRejectedValueOnce(new Error("Aptos RPC error"));
+      const walletOptions: WalletOptions = {
+        provider: {} as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0x1", chainId: "mainnet", network: "mainnet" },
+      };
+      await expect(
+        getBalance({ chainId: "mainnet", address: "0x1" }, walletOptions),
+      ).rejects.toThrow("Aptos RPC error");
+    });
+
+    it("should get balance for Dogecoin", async () => {
+      const mockProvider = {
+        getBalance: vi.fn().mockResolvedValue({ balance: "1000000" }),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "DogeAddress123",
+          chainId: "mainnet",
+        },
+      };
+
+      const result = await getBalance(
+        {
+          chainId: "mainnet",
+        },
+        walletOptions,
+      );
+
+      expect(result).toHaveProperty("total");
+      expect(mockProvider.getBalance).toHaveBeenCalled();
+    });
+  });
+
+  describe("switchChain", () => {
+    it("should switch chain for EVM", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue(null),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      const result = await switchChain("0x5", walletOptions);
+      expect(result).toBe(true);
+      expect(mockProvider.request).toHaveBeenCalledWith({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: "0x5" }],
+      });
+    });
+
+    it("should throw error when provider is missing", async () => {
+      const walletOptions: WalletOptions = {
+        provider: undefined as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(switchChain("0x5", walletOptions)).rejects.toThrow("Provider is required");
+    });
+
+    it("should throw error when chainType is missing", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: undefined as any,
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(switchChain("0x5", walletOptions)).rejects.toThrow("Chain type is required");
+    });
+
+    it("should throw error for unsupported chain type", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(switchChain("0x5", walletOptions)).rejects.toThrow("switchChain Not supported in solana");
+    });
+
+    it("should throw when chainId is empty or invalid", async () => {
+      const mockProvider = { request: vi.fn() };
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      await expect(switchChain("", walletOptions)).rejects.toThrow("Chain ID is required");
+    });
+
+    it("should rethrow when provider.request fails in switchChain", async () => {
+      const mockProvider = {
+        request: vi.fn().mockRejectedValue(new Error("User rejected")),
+      };
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      await expect(switchChain("0x5", walletOptions)).rejects.toThrow("User rejected");
+    });
+  });
+
+  describe("addChain", () => {
+    it("should add chain for EVM", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue(null),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      const chainInfo = {
+        chainId: "0x5",
+        chainName: "Goerli",
+        nativeCurrency: {
+          name: "ETH",
+          symbol: "ETH",
+          decimals: 18,
+        },
+        rpcUrls: ["https://goerli.infura.io/v3/"],
+      };
+
+      const result = await addChain(chainInfo, walletOptions);
+      expect(result).toBe(true);
+      expect(mockProvider.request).toHaveBeenCalledWith({
+        method: "wallet_addEthereumChain",
+        params: [chainInfo],
+      });
+    });
+
+    it("should convert decimal chainId to hex", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue(null),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      const chainInfo = {
+        chainId: "5",
+        chainName: "Goerli",
+        nativeCurrency: {
+          name: "ETH",
+          symbol: "ETH",
+          decimals: 18,
+        },
+        rpcUrls: ["https://goerli.infura.io/v3/"],
+      };
+
+      await addChain(chainInfo, walletOptions);
+      expect(chainInfo.chainId).toBe("0x5");
+    });
+
+    it("should throw error when chainId is missing", async () => {
+      const mockProvider = {
+        request: vi.fn(),
+      };
+
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(addChain({} as any, walletOptions)).rejects.toThrow("Chain ID is required");
+    });
+
+    it("should throw when provider is missing in addChain", async () => {
+      const walletOptions: WalletOptions = {
+        provider: undefined as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      await expect(
+        addChain({ chainId: "0x5", chainName: "Goerli", rpcUrls: [] }, walletOptions),
+      ).rejects.toThrow("Provider is required");
+    });
+
+    it("should throw when chainType is missing in addChain", async () => {
+      const walletOptions: WalletOptions = {
+        provider: { request: vi.fn() } as any,
+        chainType: undefined as any,
+        walletInfo: {} as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      await expect(
+        addChain({ chainId: "0x5", chainName: "Goerli", rpcUrls: [] }, walletOptions),
+      ).rejects.toThrow("Chain type is required");
+    });
+
+    it("should rethrow when provider.request fails in addChain", async () => {
+      const mockProvider = {
+        request: vi.fn().mockRejectedValue(new Error("Add chain failed")),
+      };
+      const walletOptions: WalletOptions = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      await expect(
+        addChain({ chainId: "0x5", chainName: "Goerli", rpcUrls: [] }, walletOptions),
+      ).rejects.toThrow("Add chain failed");
+    });
+
+    it("should throw for unsupported chain type in addChain", async () => {
+      const walletOptions: WalletOptions = {
+        provider: { request: vi.fn() } as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      await expect(
+        addChain({ chainId: "0x5", chainName: "Goerli", rpcUrls: [] }, walletOptions),
+      ).rejects.toThrow("addChain Not supported in solana");
+    });
+  });
+
+  describe("signInWithWallet", () => {
+    const baseSignInData = {
+      domain: "example.com",
+      scheme: "https",
+      nonce: "test-nonce",
+    };
+
+    it("should sign in with EVM wallet", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue("0xsignature"),
+      };
+
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      const signInData = {
+        ...baseSignInData,
+        statement: "Sign in",
+        version: "1",
+        issuedAt: new Date().toISOString(),
+      };
+
+      const result = await signInWithWallet(signInData, walletOptions);
+      expect(result).toBe("0xsignature");
+    });
+
+    it("should sign in with Aptos wallet", async () => {
+      const mockProvider = {
+        signMessage: vi.fn().mockResolvedValue({ args: { signature: "0xaptos-sig" } }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0xaptos", chainId: "mainnet" },
+      };
+      const result = await signInWithWallet(
+        { ...baseSignInData, statement: "Sign", version: "1", issuedAt: new Date().toISOString() },
+        walletOptions,
+      );
+      expect(result).toBeDefined();
+    });
+
+    it("should sign in with Solana wallet via signIn", async () => {
+      const mockProvider = {
+        signIn: vi.fn().mockResolvedValue({ signature: { toHex: () => "0xsol-sig" } }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      const signInData = {
+        ...baseSignInData,
+        domain: "example.com",
+        scheme: "https",
+        statement: "Sign",
+        version: "1",
+        issuedAt: new Date().toISOString(),
+        resources: ["https://example.com"] as `https://${string}`[],
+      };
+      const result = await signInWithWallet(signInData, walletOptions);
+      expect(result).toBe("0xsol-sig");
+      expect(mockProvider.signIn).toHaveBeenCalled();
+    });
+
+    it("should sign in with Solana wallet via solana:signIn", async () => {
+      const mockProvider = {
+        "solana:signIn": {
+          signIn: vi.fn().mockResolvedValue("0xsol-sig-string"),
+        },
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      const result = await signInWithWallet(
+        { ...baseSignInData, domain: "example.com", scheme: "https" },
+        walletOptions,
+      );
+      expect(result).toBe("0xsol-sig-string");
+    });
+
+    it("should sign in with Solana when signIn returns array with signature", async () => {
+      const mockProvider = {
+        signIn: vi.fn().mockResolvedValue([{ signature: { toHex: () => "0xsol-array-sig" } }]),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      const result = await signInWithWallet(
+        { ...baseSignInData, domain: "example.com", scheme: "https" },
+        walletOptions,
+      );
+      expect(result).toBe("0xsol-array-sig");
+    });
+
+    it("should sign in with Solana when signIn returns plain string", async () => {
+      const mockProvider = {
+        signIn: vi.fn().mockResolvedValue("0xsol-plain-string"),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      const result = await signInWithWallet(
+        { ...baseSignInData, domain: "example.com", scheme: "https" },
+        walletOptions,
+      );
+      expect(result).toBe("0xsol-plain-string");
+    });
+
+    it("should sign in with Solana via signMessage when no signIn method", async () => {
+      const mockProvider = {
+        signMessage: vi.fn().mockResolvedValue({ signature: { toHex: () => "0xfallback-sig" } }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      const result = await signInWithWallet(
+        { ...baseSignInData, domain: "example.com", scheme: "https", nonce: "n1" },
+        walletOptions,
+      );
+      expect(result).toBe("0xfallback-sig");
+      expect(mockProvider.signMessage).toHaveBeenCalled();
+    });
+
+    it("should rethrow when Solana signIn throws", async () => {
+      const mockProvider = {
+        signIn: vi.fn().mockRejectedValue(new Error("User rejected")),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      await expect(
+        signInWithWallet(
+          { ...baseSignInData, domain: "example.com", scheme: "https" },
+          walletOptions,
+        ),
+      ).rejects.toThrow("User rejected");
+    });
+
+    it("should sign in with Dogecoin wallet", async () => {
+      const mockProvider = {
+        requestSignedMessage: vi.fn().mockResolvedValue({ signedMessage: "0xdogecoin-sig" }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+        account: { address: "DogeAddr", chainId: "" },
+      };
+      const result = await signInWithWallet(
+        { ...baseSignInData, domain: "example.com", scheme: "https" },
+        walletOptions,
+      );
+      expect(result).toBe("0xdogecoin-sig");
+    });
+
+    it("should throw for unsupported chain type", async () => {
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: { request: vi.fn() } as any,
+        chainType: "bitcoin" as any,
+        walletInfo: {} as WalletInfo,
+        account: { address: "addr", chainId: "" },
+      };
+      await expect(signInWithWallet(baseSignInData as any, walletOptions)).rejects.toThrow(
+        "signInWithWallet not supported in bitcoin",
+      );
+    });
+
+    it("should throw error when provider is missing", async () => {
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: undefined as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(signInWithWallet({} as any, walletOptions)).rejects.toThrow("Provider is required");
+    });
+  });
+
+  describe("signMessage", () => {
+    it("should sign message for EVM", async () => {
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue("0xsignature"),
+      };
+
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      const result = await signMessage({ message: "test message" }, walletOptions);
+      expect(result).toBe("0xsignature");
+      expect(mockProvider.request).toHaveBeenCalledWith({
+        method: "personal_sign",
+        params: ["test message", "0x123"],
+      });
+    });
+
+    it("should schedule delayed mobile wallet open for EVM when isMobile and not installed", async () => {
+      vi.useFakeTimers();
+      mockIsMobile.mockReturnValueOnce(true);
+      const mockGetDeeplink = vi.fn().mockResolvedValue("myapp://sign");
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue("0xsignature"),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        isInstalled: false,
+        walletInfo: { uuid: "phantom", mobile: { getDeeplink: mockGetDeeplink } } as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      global.window = { ...global.window, location: { href: "https://example.com" } } as any;
+
+      const resultPromise = signMessage({ message: "test" }, walletOptions);
+      await vi.advanceTimersByTimeAsync(350);
+      const result = await resultPromise;
+      expect(result).toBe("0xsignature");
+      expect(mockGetDeeplink).toHaveBeenCalledWith("https://example.com", 1);
+      expect(mockOpenUri).toHaveBeenCalledWith("myapp://sign");
+      vi.useRealTimers();
+    });
+
+    it("should not open URI when mobile getDeeplink returns null", async () => {
+      mockIsMobile.mockReturnValueOnce(true);
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue("0xsig"),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        isInstalled: false,
+        walletInfo: { uuid: "phantom", mobile: { getDeeplink: vi.fn().mockResolvedValue(null) } } as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      const result = await signMessage({ message: "test" }, walletOptions);
+      expect(result).toBe("0xsig");
+      expect(mockOpenUri).not.toHaveBeenCalled();
+    });
+
+    it("should log error when mobile getDeeplink rejects", async () => {
+      mockIsMobile.mockReturnValueOnce(true);
+      const err = new Error("getDeeplink failed");
+      const mockProvider = {
+        request: vi.fn().mockResolvedValue("0xsig"),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "evm",
+        isInstalled: false,
+        walletInfo: { uuid: "phantom", mobile: { getDeeplink: vi.fn().mockRejectedValue(err) } } as WalletInfo,
+        account: { address: "0x123", chainId: "0x1" },
+      };
+      const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const result = await signMessage({ message: "test" }, walletOptions);
+      expect(result).toBe("0xsig");
+      await vi.waitFor(() => {
+        expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to schedule mobile wallet open:", err);
+      });
+      consoleErrorSpy.mockRestore();
+    });
+
+    it("should sign message for Solana via signMessage", async () => {
+      const mockProvider = {
+        signMessage: vi.fn().mockResolvedValue({ signature: { toHex: () => "0xsol-sig" } }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello" }, walletOptions);
+      expect(result).toBe("0xsol-sig");
+    });
+
+    it("should sign message for Solana via signMessage returning string", async () => {
+      const mockProvider = {
+        signMessage: vi.fn().mockResolvedValue("0xsol-string-sig"),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello" }, walletOptions);
+      expect(result).toBe("0xsol-string-sig");
+    });
+
+    it("should sign message for Solana via solana:signMessage", async () => {
+      const mockProvider = {
+        "solana:signMessage": {
+          signMessage: vi.fn().mockResolvedValue([{ signature: { toHex: () => "0xsol-sig2" } }]),
+        },
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello" }, walletOptions);
+      expect(result).toBe("0xsol-sig2");
+    });
+
+    it("should throw when Solana has no signMessage support", async () => {
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: {} as any,
+        chainType: "solana",
+        walletInfo: {} as WalletInfo,
+        account: { address: "SolanaAddr", chainId: "" },
+      };
+      await expect(signMessage({ message: "hello" }, walletOptions)).rejects.toThrow(
+        "signMessage solana not supported",
+      );
+    });
+
+    it("should sign message for Aptos via signMessage (signature with toHex)", async () => {
+      const mockProvider = {
+        signMessage: vi.fn().mockResolvedValue({
+          args: { signature: { data: { data: { toHex: () => "0xaptos-sig" } } } },
+        }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0xaptos", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello", nonce: "n1" }, walletOptions);
+      expect(result).toBe("0xaptos-sig");
+    });
+
+    it("should sign message for Aptos (res.signature string like okx)", async () => {
+      const mockProvider = {
+        signMessage: vi.fn().mockResolvedValue({ signature: "0xokx-string-sig" }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0xaptos", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello", nonce: "n1" }, walletOptions);
+      expect(result).toBe("0xokx-string-sig");
+    });
+
+    it("should sign message for Aptos (gate wallet style data.data object)", async () => {
+      const mockProvider = {
+        signMessage: vi.fn().mockResolvedValue({
+          args: { signature: { data: { data: { 0: 97, 1: 112, 2: 116, 3: 111, 4: 115 } } } },
+        }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0xaptos", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello", nonce: "n1" }, walletOptions);
+      expect(result).toBe("6170746f73");
+    });
+
+    it("should sign message for Aptos (args.signature object fallback)", async () => {
+      const mockProvider = {
+        signMessage: vi.fn().mockResolvedValue({
+          args: { signature: { otherKey: "0xfallback-hex" } },
+        }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0xaptos", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello", nonce: "n1" }, walletOptions);
+      expect(result).toBeDefined();
+    });
+
+    it("should sign message for Aptos via aptos:signMessage", async () => {
+      const mockProvider = {
+        "aptos:signMessage": {
+          signMessage: vi.fn().mockResolvedValue({
+            args: { signature: { signature: Buffer.from("aptos") } },
+          }),
+        },
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0xaptos", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello", nonce: "n1" }, walletOptions);
+      expect(result).toBeDefined();
+    });
+
+    it("should throw when Aptos has no signMessage support", async () => {
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: {} as any,
+        chainType: "aptos",
+        walletInfo: {} as WalletInfo,
+        account: { address: "0xaptos", chainId: "" },
+      };
+      await expect(signMessage({ message: "hello", nonce: "n1" }, walletOptions)).rejects.toThrow(
+        "signMessage aptos not supported",
+      );
+    });
+
+    it("should sign message for Dogecoin", async () => {
+      const mockProvider = {
+        requestSignedMessage: vi.fn().mockResolvedValue({ signedMessage: "doge-sig" }),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+        account: { address: "DogeAddr", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello", type: "text" }, walletOptions);
+      expect(result).toBe("doge-sig");
+    });
+
+    it("should return empty string when Dogecoin requestSignedMessage returns no signedMessage", async () => {
+      const mockProvider = {
+        requestSignedMessage: vi.fn().mockResolvedValue({}),
+      };
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: mockProvider as any,
+        chainType: "dogecoin",
+        walletInfo: {} as WalletInfo,
+        account: { address: "DogeAddr", chainId: "" },
+      };
+      const result = await signMessage({ message: "hello", type: "text" }, walletOptions);
+      expect(result).toBe("");
+    });
+
+    it("should throw for unsupported chain type", async () => {
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: { request: vi.fn() } as any,
+        chainType: "bitcoin" as any,
+        walletInfo: {} as WalletInfo,
+        account: { address: "addr", chainId: "" },
+      };
+      await expect(signMessage({ message: "hi" }, walletOptions)).rejects.toThrow(
+        "signMessage not supported in bitcoin",
+      );
+    });
+
+    it("should throw error when provider is missing", async () => {
+      const walletOptions: WalletOptions & { isInstalled?: boolean } = {
+        provider: undefined as any,
+        chainType: "evm",
+        walletInfo: {} as WalletInfo,
+        account: {
+          address: "0x123",
+          chainId: "0x1",
+        },
+      };
+
+      await expect(signMessage({ message: "test" }, walletOptions)).rejects.toThrow("Provider is required");
+    });
+  });
+});