@multiplatform.one/web3 7.17.0 → 7.19.0

package/src/clients/hooks.spec.tsx

@@ -0,0 +1,113 @@
+// @vitest-environment happy-dom
+import { renderHook } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { getBase58Decoder } from "@solana/kit";
+import { createPublicClient, createWalletClient, custom } from "viem";
+import { mainnet } from "viem/chains";
+import { Web3ConfigContext, type Web3Config } from "../providers/walletConfig";
+
+const { mockUseAccount, mockUseWalletClient, mockUsePublicClient } = vi.hoisted(() => ({
+  mockUseAccount: vi.fn(),
+  mockUseWalletClient: vi.fn(),
+  mockUsePublicClient: vi.fn(),
+}));
+
+vi.mock("wagmi", () => ({
+  useAccount: mockUseAccount,
+  useWalletClient: mockUseWalletClient,
+  usePublicClient: mockUsePublicClient,
+}));
+
+import { useBitcoinClient, useEvmClient, useSuiClient } from "./hooks";
+import { useSolanaClient } from "./useSolanaClient";
+
+const evmAddress = "0x1111111111111111111111111111111111111111";
+const solanaAddress = getBase58Decoder().decode(new Uint8Array(32).fill(7));
+const provider = { request: vi.fn() };
+const walletClient = createWalletClient({
+  account: evmAddress,
+  chain: mainnet,
+  transport: custom(provider),
+});
+const publicClient = createPublicClient({ chain: mainnet, transport: custom(provider) });
+
+const shim = (ecosystem: string, address: string) => ({
+  id: `wallet:${ecosystem}`,
+  type: "wallet",
+  ecosystem,
+  adapter: { address, signMessage: vi.fn(async () => "sig") },
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockUseWalletClient.mockReturnValue({ data: undefined });
+  mockUsePublicClient.mockReturnValue(publicClient);
+});
+
+describe("useEvmClient", () => {
+  it("wraps the connected EVM wallet", () => {
+    mockUseAccount.mockReturnValue({ connector: { id: "metaMask" }, chainId: 1 });
+    mockUseWalletClient.mockReturnValue({ data: walletClient });
+    const { result } = renderHook(() => useEvmClient());
+    expect(result.current?.family).toBe("evm");
+    expect(result.current?.address).toBe(evmAddress);
+    expect(result.current?.chainId).toBe(1);
+    expect(mockUseWalletClient).toHaveBeenCalledWith(
+      expect.objectContaining({ query: { enabled: true } }),
+    );
+  });
+
+  it("stays undefined, and does not query, while a non-EVM wallet is connected", () => {
+    mockUseAccount.mockReturnValue({ connector: shim("solana", solanaAddress), chainId: 0x534f4c });
+    const { result } = renderHook(() => useEvmClient());
+    expect(result.current).toBeUndefined();
+    expect(mockUseWalletClient).toHaveBeenCalledWith(
+      expect.objectContaining({ query: { enabled: false } }),
+    );
+  });
+
+  it("is undefined before a wallet connects", () => {
+    mockUseAccount.mockReturnValue({ connector: undefined });
+    expect(renderHook(() => useEvmClient()).result.current).toBeUndefined();
+  });
+});
+
+describe("useSolanaClient", () => {
+  const wrapper =
+    (config: Partial<Web3Config>) =>
+    ({ children }: { children: ReactNode }) => (
+      <Web3ConfigContext.Provider value={config as Web3Config}>
+        {children}
+      </Web3ConfigContext.Provider>
+    );
+
+  it("builds the client from the connected Solana wallet and Web3Config.solanaRpcUrl", () => {
+    mockUseAccount.mockReturnValue({
+      connector: shim("solana", solanaAddress),
+      address: solanaAddress,
+    });
+    const { result } = renderHook(() => useSolanaClient(), {
+      wrapper: wrapper({ solanaRpcUrl: "https://api.devnet.solana.com" }),
+    });
+    expect(result.current?.family).toBe("solana");
+    expect(result.current?.address).toBe(solanaAddress);
+    expect(result.current?.chainId).toBe("solana:devnet");
+  });
+
+  it("is undefined for an EVM connection", () => {
+    mockUseAccount.mockReturnValue({ connector: { id: "metaMask" }, address: evmAddress });
+    expect(renderHook(() => useSolanaClient()).result.current).toBeUndefined();
+  });
+});
+
+describe("useSuiClient / useBitcoinClient", () => {
+  it("return the client only for their own ecosystem", () => {
+    mockUseAccount.mockReturnValue({ connector: shim("sui", "0xsui"), address: "0xsui" });
+    expect(renderHook(() => useSuiClient()).result.current?.address).toBe("0xsui");
+    expect(renderHook(() => useBitcoinClient()).result.current).toBeUndefined();
+
+    mockUseAccount.mockReturnValue({ connector: shim("bitcoin", "bc1q"), address: "bc1q" });
+    expect(renderHook(() => useBitcoinClient()).result.current?.chainId).toBe("bitcoin");
+  });
+});

package/src/clients/hooks.ts

@@ -0,0 +1,51 @@
+import { useMemo } from "react";
+import { useAccount, usePublicClient, useWalletClient } from "wagmi";
+import { isSyntheticChainId } from "../connectkit/connectors/syntheticChains";
+import { bitcoinClient, type BitcoinClient } from "./bitcoin";
+import { connectorAdapter } from "./adapter";
+import { evmClient, type EvmClient, type EvmWalletClient } from "./evm";
+import { suiClient, type SuiClient } from "./sui";
+import type { PublicClient } from "viem";
+
+/**
+ * The connected EVM wallet as a viem WalletClient plus a PublicClient for reads,
+ * wrapped in the mpo EVM client. Undefined until an EVM wallet is connected, and
+ * while a non-EVM wallet holds the connection.
+ */
+export function useEvmClient(parameters: { chainId?: number } = {}): EvmClient | undefined {
+  const { connector, chainId: connectedChainId } = useAccount();
+  const evm = !!connector && !connectorAdapter(connector) && !isSyntheticChainId(connectedChainId);
+  const { data: walletClient } = useWalletClient({
+    chainId: parameters.chainId,
+    query: { enabled: evm },
+  });
+  const publicClient = usePublicClient({ chainId: walletClient?.chain.id ?? parameters.chainId });
+  return useMemo(
+    () =>
+      evm && walletClient && publicClient
+        ? evmClient({
+            walletClient: walletClient as unknown as EvmWalletClient,
+            publicClient: publicClient as PublicClient,
+          })
+        : undefined,
+    [evm, walletClient, publicClient],
+  );
+}
+
+/** The connected Sui wallet (message signing only for now). */
+export function useSuiClient(): SuiClient | undefined {
+  const { connector, address } = useAccount();
+  return useMemo(() => {
+    const adapter = connectorAdapter(connector, "sui");
+    return adapter?.address ? suiClient(adapter) : undefined;
+  }, [connector, address]);
+}
+
+/** The connected Bitcoin wallet (message signing only for now). */
+export function useBitcoinClient(): BitcoinClient | undefined {
+  const { connector, address } = useAccount();
+  return useMemo(() => {
+    const adapter = connectorAdapter(connector, "bitcoin");
+    return adapter?.address ? bitcoinClient(adapter) : undefined;
+  }, [connector, address]);
+}

package/src/clients/index.ts

@@ -0,0 +1,40 @@
+// Per-chain clients: the one way an app talks to a chain through mpo web3.
+// Each client shares { family, address, chainId?, capabilities, signMessage }
+// and adds what its family can do. The full Solana client is the web-only
+// `./solana` subpath, not this barrel: the root is the native entry too, and
+// native signs Solana through the WebView bridge, so @solana/kit must never
+// enter that bundle, and sign-in (solanaMessageClient) does not need it.
+export {
+  UnsupportedClientMethodError,
+  type ChainClient,
+  type ClientCapability,
+  type ClientFamily,
+} from "./types";
+export {
+  evmClient,
+  type Erc20Actions,
+  type EvmClient,
+  type EvmClientConfig,
+  type EvmSendTransactionParameters,
+  type EvmWalletClient,
+  type EvmWriteContractParameters,
+} from "./evm";
+export { suiClient, type SuiClient } from "./sui";
+export { bitcoinClient, type BitcoinClient } from "./bitcoin";
+export {
+  assertGpgSignature,
+  createGpgSigner,
+  gpgSignCommand,
+  useGpgSigner,
+  type GpgSigner,
+  type GpgSignRequest,
+} from "./gpg";
+export { connectorAdapter } from "./adapter";
+export { clientForConnector, type ConnectorClientOptions, type NonEvmClient } from "./connector";
+export {
+  solanaMessageClient,
+  type SolanaChain,
+  type SolanaCluster,
+  type SolanaMessageClient,
+} from "./solanaMessage";
+export { useBitcoinClient, useEvmClient, useSuiClient } from "./hooks";

package/src/clients/solana.spec.ts

@@ -0,0 +1,444 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  address,
+  appendTransactionMessageInstruction,
+  compileTransaction,
+  createTransactionMessage,
+  getBase58Decoder,
+  getBase58Encoder,
+  getCompiledTransactionMessageDecoder,
+  getTransactionDecoder,
+  getTransactionEncoder,
+  pipe,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  type Blockhash,
+  type Rpc,
+  type SolanaRpcApi,
+} from "@solana/kit";
+import {
+  connectSolanaWallet,
+  injectedSolanaSigner,
+  solanaChainFromRpcUrl,
+  solanaClient,
+  standardSolanaSigner,
+  transferSolInstruction,
+  SolanaConfirmationError,
+  type SolanaSigner,
+} from "./solana";
+import { UnsupportedClientMethodError } from "./types";
+import {
+  getSolanaWallets,
+  type StandardWallet,
+  type StandardWalletAccount,
+} from "./walletStandard";
+
+const b58 = (bytes: Uint8Array) => getBase58Decoder().decode(bytes);
+const owner = b58(new Uint8Array(32).fill(7));
+const other = b58(new Uint8Array(32).fill(9));
+// A leading zero byte is the case where base58 codecs most often disagree.
+const signatureBytes = Uint8Array.from({ length: 64 }, (_, i) => (i === 0 ? 0 : i));
+
+function sampleTransaction() {
+  const message = pipe(
+    createTransactionMessage({ version: 0 }),
+    (m) => setTransactionMessageFeePayer(address(owner), m),
+    (m) =>
+      setTransactionMessageLifetimeUsingBlockhash(
+        { blockhash: b58(new Uint8Array(32).fill(3)) as Blockhash, lastValidBlockHeight: 10n },
+        m,
+      ),
+    (m) =>
+      appendTransactionMessageInstruction(
+        transferSolInstruction(address(owner), address(other), 5n),
+        m,
+      ),
+  );
+  return compileTransaction(message);
+}
+
+function mockSigner(overrides: Partial<SolanaSigner> = {}): SolanaSigner {
+  return {
+    address: owner,
+    signMessage: vi.fn(async () => signatureBytes),
+    signTransaction: vi.fn(async (tx: Uint8Array) => tx),
+    ...overrides,
+  };
+}
+
+const registered: ((event: Event) => void)[] = [];
+function registerWallet(wallet: StandardWallet) {
+  const listener = (event: Event) =>
+    ((event as CustomEvent).detail as { register(w: StandardWallet): void }).register(wallet);
+  window.addEventListener("wallet-standard:app-ready", listener);
+  registered.push(listener);
+}
+
+function mockWallet(name: string, accounts: StandardWalletAccount[], withSend = true) {
+  const features: Record<string, unknown> = {
+    "standard:connect": { connect: vi.fn(async () => ({ accounts })) },
+    "solana:signMessage": {
+      signMessage: vi.fn(async () => [
+        { signedMessage: new Uint8Array(), signature: signatureBytes },
+      ]),
+    },
+    "solana:signTransaction": {
+      signTransaction: vi.fn(async ({ transaction }: { transaction: Uint8Array }) => [
+        { signedTransaction: transaction },
+      ]),
+    },
+  };
+  if (withSend) {
+    features["solana:signAndSendTransaction"] = {
+      signAndSendTransaction: vi.fn(async () => [{ signature: signatureBytes }]),
+    };
+  }
+  return { name, chains: ["solana:mainnet"], accounts, features } as StandardWallet;
+}
+
+const account = (addr: string): StandardWalletAccount => ({
+  address: addr,
+  publicKey: getBase58Encoder().encode(addr) as Uint8Array,
+  chains: ["solana:mainnet", "solana:devnet"],
+  features: [],
+});
+
+afterEach(() => {
+  for (const listener of registered.splice(0)) {
+    window.removeEventListener("wallet-standard:app-ready", listener);
+  }
+});
+
+describe("solanaClient", () => {
+  it("shares the common client shape", () => {
+    const client = solanaClient({ signer: mockSigner(), rpcUrl: "https://api.devnet.solana.com" });
+    expect(client.family).toBe("solana");
+    expect(client.address).toBe(owner);
+    expect(client.chainId).toBe("solana:devnet");
+    expect(client.capabilities).toContain("signAndSendTransaction");
+  });
+
+  it("returns the base58 signature over the UTF-8 message bytes", async () => {
+    const signer = mockSigner();
+    const client = solanaClient({ signer });
+    await expect(client.signMessage("héllo")).resolves.toBe(b58(signatureBytes));
+    expect(signer.signMessage).toHaveBeenCalledWith(new TextEncoder().encode("héllo"));
+  });
+
+  it("hands the wallet wire bytes and decodes what it signs", async () => {
+    const tx = sampleTransaction();
+    const signer = mockSigner();
+    const client = solanaClient({ signer });
+    const signed = await client.signTransaction(tx);
+    expect(signer.signTransaction).toHaveBeenCalledWith(
+      Uint8Array.from(getTransactionEncoder().encode(tx)),
+    );
+    expect(signed.messageBytes).toEqual(tx.messageBytes);
+  });
+
+  it("lets the wallet sign and send when it can", async () => {
+    const signAndSendTransaction = vi.fn(async () => signatureBytes);
+    const rpc = { sendTransaction: vi.fn() } as unknown as Rpc<SolanaRpcApi>;
+    const client = solanaClient({ signer: mockSigner({ signAndSendTransaction }), rpc });
+    await expect(client.signAndSendTransaction(sampleTransaction())).resolves.toEqual({
+      signature: b58(signatureBytes),
+      lastValidBlockHeight: 10n,
+    });
+    expect(rpc.sendTransaction).not.toHaveBeenCalled();
+  });
+
+  it("signs, then sends over its own RPC when the wallet cannot send", async () => {
+    const send = vi.fn(async () => "sent-signature");
+    const rpc = {
+      sendTransaction: vi.fn(() => ({ send })),
+    } as unknown as Rpc<SolanaRpcApi>;
+    const signer = mockSigner();
+    const client = solanaClient({ signer, rpc });
+    await expect(client.signAndSendTransaction(sampleTransaction())).resolves.toEqual({
+      signature: "sent-signature",
+      lastValidBlockHeight: 10n,
+    });
+    expect(signer.signTransaction).toHaveBeenCalledOnce();
+    expect(rpc.sendTransaction).toHaveBeenCalledWith(expect.any(String), { encoding: "base64" });
+  });
+
+  it("falls back to sign-then-send when sign-and-send is unsupported", async () => {
+    const send = vi.fn(async () => "sent-signature");
+    const rpc = { sendTransaction: vi.fn(() => ({ send })) } as unknown as Rpc<SolanaRpcApi>;
+    const signAndSendTransaction = vi.fn(async () => {
+      throw new UnsupportedClientMethodError("solana", "signAndSendTransaction");
+    });
+    const client = solanaClient({ signer: mockSigner({ signAndSendTransaction }), rpc });
+    await expect(client.signAndSendTransaction(sampleTransaction())).resolves.toMatchObject({
+      signature: "sent-signature",
+    });
+  });
+
+  it("has no lastValidBlockHeight for wire bytes, which carry no lifetime", async () => {
+    const send = vi.fn(async () => "sent-signature");
+    const rpc = { sendTransaction: vi.fn(() => ({ send })) } as unknown as Rpc<SolanaRpcApi>;
+    const wire = Uint8Array.from(getTransactionEncoder().encode(sampleTransaction()));
+    await expect(
+      solanaClient({ signer: mockSigner(), rpc }).sendTransaction(wire),
+    ).resolves.toEqual({
+      signature: "sent-signature",
+      lastValidBlockHeight: undefined,
+    });
+  });
+
+  it("confirms by polling signature status and surfaces a failed transaction", async () => {
+    const statuses = [
+      null,
+      { confirmationStatus: "processed" },
+      { confirmationStatus: "confirmed" },
+    ];
+    const rpc = {
+      getSignatureStatuses: vi.fn(() => ({ send: async () => ({ value: [statuses.shift()] }) })),
+    } as unknown as Rpc<SolanaRpcApi>;
+    const client = solanaClient({ signer: mockSigner(), rpc });
+    await expect(client.confirmTransaction("sig" as never, { pollMs: 0 })).resolves.toBeUndefined();
+
+    const failing = {
+      getSignatureStatuses: () => ({
+        send: async () => ({ value: [{ err: { InstructionError: [0, "x"] } }] }),
+      }),
+    } as unknown as Rpc<SolanaRpcApi>;
+    const error = await solanaClient({ signer: mockSigner(), rpc: failing })
+      .confirmTransaction("sig" as never)
+      .catch((e: unknown) => e);
+    expect(error).toBeInstanceOf(SolanaConfirmationError);
+    expect(error).toMatchObject({ reason: "failed", mayStillLand: false });
+    expect((error as Error).message).toMatch(/failed on chain.*safe to retry/);
+  });
+});
+
+describe("confirmTransaction against the blockhash lifetime", () => {
+  // A chain whose block height walks through `heights` (the last one repeats)
+  // while the signature has the statuses in `statuses` (null once they run out).
+  function chain(heights: bigint[], statuses: ({ confirmationStatus: string } | null)[]) {
+    const height = [...heights];
+    const status = [...statuses];
+    return {
+      getSignatureStatuses: vi.fn(() => ({
+        send: async () => ({ value: [status.length ? status.shift() : null] }),
+      })),
+      getBlockHeight: vi.fn(() => ({
+        send: async () => (height.length > 1 ? height.shift() : height[0]),
+      })),
+    } as unknown as Rpc<SolanaRpcApi> & {
+      getBlockHeight: ReturnType<typeof vi.fn>;
+    };
+  }
+
+  it("keeps waiting past any fixed timeout while the blockhash is still valid", async () => {
+    const rpc = chain([5n, 8n, 10n], [null, null, null, { confirmationStatus: "confirmed" }]);
+    const client = solanaClient({ signer: mockSigner(), rpc });
+    await expect(
+      client.confirmTransaction(
+        { signature: "sig" as never, lastValidBlockHeight: 10n },
+        { timeoutMs: 0, pollMs: 0 },
+      ),
+    ).resolves.toBeUndefined();
+    expect(rpc.getBlockHeight).toHaveBeenCalledTimes(3);
+  });
+
+  it("fails as expired, safe to retry, once the height passes lastValidBlockHeight", async () => {
+    const rpc = chain([9n, 11n], []);
+    const error = await solanaClient({ signer: mockSigner(), rpc })
+      .confirmTransaction({ signature: "sig" as never, lastValidBlockHeight: 10n }, { pollMs: 0 })
+      .catch((e: unknown) => e);
+    expect(error).toBeInstanceOf(SolanaConfirmationError);
+    expect(error).toMatchObject({ reason: "expired", mayStillLand: false });
+    expect((error as Error).message).toMatch(/block height 11 passed 10.*will not land/);
+  });
+
+  it("confirms a transaction that landed in the last valid block", async () => {
+    const rpc = chain([11n], [null, { confirmationStatus: "confirmed" }]);
+    await expect(
+      solanaClient({ signer: mockSigner(), rpc }).confirmTransaction(
+        { signature: "sig" as never, lastValidBlockHeight: 10n },
+        { pollMs: 0 },
+      ),
+    ).resolves.toBeUndefined();
+  });
+
+  it("without a lastValidBlockHeight, times out saying it may still land", async () => {
+    const rpc = chain([1n], []);
+    const error = await solanaClient({ signer: mockSigner(), rpc })
+      .confirmTransaction("sig" as never, { timeoutMs: 1, pollMs: 1 })
+      .catch((e: unknown) => e);
+    expect(error).toMatchObject({ reason: "timeout", mayStillLand: true });
+    expect((error as Error).message).toMatch(/may still land, so do not resend/);
+    expect(rpc.getBlockHeight).not.toHaveBeenCalled();
+  });
+});
+
+describe("transferSol", () => {
+  const blockhash = b58(new Uint8Array(32).fill(4));
+
+  function rpcFor(send: () => Promise<string>) {
+    return {
+      getLatestBlockhash: vi.fn(() => ({
+        send: async () => ({ value: { blockhash, lastValidBlockHeight: 99n } }),
+      })),
+      sendTransaction: vi.fn(() => ({ send })),
+    } as unknown as Rpc<SolanaRpcApi> & { sendTransaction: ReturnType<typeof vi.fn> };
+  }
+
+  it("builds a System Program transfer on the latest blockhash, signs, sends it, and returns its lifetime", async () => {
+    const rpc = rpcFor(async () => "sent-signature");
+    const signer = mockSigner();
+    const client = solanaClient({ signer, rpc });
+    await expect(client.transferSol({ to: other, lamports: 1_500_000n })).resolves.toEqual({
+      signature: "sent-signature",
+      lastValidBlockHeight: 99n,
+    });
+
+    const wire = vi.mocked(signer.signTransaction).mock.calls[0][0];
+    const tx = getTransactionDecoder().decode(wire);
+    const message = getCompiledTransactionMessageDecoder().decode(tx.messageBytes);
+    expect(message.lifetimeToken).toBe(blockhash);
+    expect(message.staticAccounts[0]).toBe(owner);
+    if (!("instructions" in message)) throw new Error("expected a v0 message");
+    expect(message.instructions).toHaveLength(1);
+    const [ix] = message.instructions;
+    expect(message.staticAccounts[ix.programAddressIndex]).toBe("11111111111111111111111111111111");
+    expect(Array.from(ix.data ?? [])).toEqual(
+      Array.from(transferSolInstruction(address(owner), address(other), 1_500_000n).data ?? []),
+    );
+    expect(ix.accountIndices?.map((i) => message.staticAccounts[i])).toEqual([owner, other]);
+    expect(rpc.sendTransaction).toHaveBeenCalledWith(expect.any(String), { encoding: "base64" });
+  });
+
+  it("returns the lifetime when the wallet signs and sends it too", async () => {
+    const rpc = rpcFor(async () => "unused");
+    const signAndSendTransaction = vi.fn(async () => signatureBytes);
+    const client = solanaClient({ signer: mockSigner({ signAndSendTransaction }), rpc });
+    await expect(client.transferSol({ to: other, lamports: 1n })).resolves.toEqual({
+      signature: b58(signatureBytes),
+      lastValidBlockHeight: 99n,
+    });
+    expect(rpc.sendTransaction).not.toHaveBeenCalled();
+  });
+
+  it("refuses lamports outside a u64 before asking the wallet", async () => {
+    const rpc = rpcFor(async () => "unused");
+    const signer = mockSigner();
+    const client = solanaClient({ signer, rpc });
+    await expect(client.transferSol({ to: other, lamports: -1n })).rejects.toBeInstanceOf(
+      RangeError,
+    );
+    await expect(client.transferSol({ to: other, lamports: 2n ** 64n })).rejects.toThrow(/u64/);
+    expect(signer.signTransaction).not.toHaveBeenCalled();
+  });
+});
+
+describe("transferSolInstruction", () => {
+  it("encodes System Program Transfer with little-endian lamports", () => {
+    const ix = transferSolInstruction(address(owner), address(other), 0x0102030405n);
+    expect(ix.programAddress).toBe("11111111111111111111111111111111");
+    expect(Array.from(ix.data ?? [])).toEqual([2, 0, 0, 0, 5, 4, 3, 2, 1, 0, 0, 0]);
+    expect(ix.accounts?.map((a) => [a.address, a.role])).toEqual([
+      [owner, 3],
+      [other, 1],
+    ]);
+  });
+
+  it("takes the full u64 range and nothing outside it", () => {
+    const max = 2n ** 64n - 1n;
+    expect(
+      Array.from(transferSolInstruction(address(owner), address(other), max).data ?? []),
+    ).toEqual([2, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255]);
+    expect(() => transferSolInstruction(address(owner), address(other), 2n ** 64n)).toThrow(
+      RangeError,
+    );
+    expect(() => transferSolInstruction(address(owner), address(other), -1n)).toThrow(RangeError);
+  });
+});
+
+describe("solanaChainFromRpcUrl", () => {
+  it("maps endpoints to Wallet Standard chains", () => {
+    expect(solanaChainFromRpcUrl()).toBe("solana:mainnet");
+    expect(solanaChainFromRpcUrl("https://api.devnet.solana.com")).toBe("solana:devnet");
+    expect(solanaChainFromRpcUrl("https://api.testnet.solana.com")).toBe("solana:testnet");
+    expect(solanaChainFromRpcUrl("http://127.0.0.1:8899")).toBe("solana:localnet");
+    expect(solanaChainFromRpcUrl("https://rpc.helius.xyz/?api-key=x")).toBe("solana:mainnet");
+  });
+});
+
+describe("Wallet Standard signers", () => {
+  it("finds registered Solana wallets", () => {
+    registerWallet(mockWallet("Phantom", [account(owner)]));
+    registerWallet({ name: "Sui only", chains: [], accounts: [], features: {} } as StandardWallet);
+    expect(getSolanaWallets().map((w) => w.name)).toEqual(["Phantom"]);
+  });
+
+  it("passes the account and chain to the wallet's features", async () => {
+    const wallet = mockWallet("Phantom", [account(owner)]);
+    const signer = standardSolanaSigner(wallet, wallet.accounts[0], "solana:devnet");
+    const wire = new Uint8Array([1, 2, 3]);
+    await signer.signTransaction(wire);
+    await signer.signAndSendTransaction?.(wire);
+    const features = wallet.features as Record<string, Record<string, ReturnType<typeof vi.fn>>>;
+    expect(features["solana:signTransaction"].signTransaction).toHaveBeenCalledWith({
+      account: wallet.accounts[0],
+      transaction: wire,
+      chain: "solana:devnet",
+    });
+    expect(features["solana:signAndSendTransaction"].signAndSendTransaction).toHaveBeenCalledWith({
+      account: wallet.accounts[0],
+      transaction: wire,
+      chain: "solana:devnet",
+    });
+  });
+
+  it("leaves sign-and-send off a wallet that lacks it", () => {
+    const wallet = mockWallet("Plain", [account(owner)], false);
+    expect(standardSolanaSigner(wallet, wallet.accounts[0]).signAndSendTransaction).toBeUndefined();
+  });
+
+  it("connects a wallet by name without the modal", async () => {
+    registerWallet(mockWallet("Phantom", [account(other)]));
+    registerWallet(mockWallet("Solflare", [account(owner)]));
+    const signer = await connectSolanaWallet({ wallet: "solflare" });
+    expect(signer.address).toBe(owner);
+    await expect(connectSolanaWallet({ wallet: "Backpack" })).rejects.toThrow(/Backpack/);
+  });
+});
+
+describe("injectedSolanaSigner", () => {
+  const adapter = () => ({ address: owner, signMessage: vi.fn(async () => b58(signatureBytes)) });
+
+  it("signs text through the adapter exactly as login did, byte-for-byte", async () => {
+    const a = adapter();
+    const client = solanaClient({ signer: injectedSolanaSigner(a) });
+    const message = "example.com wants you to sign in with your Solana account:\n" + owner;
+    await expect(client.signMessage(message)).resolves.toBe(b58(signatureBytes));
+    expect(a.signMessage).toHaveBeenCalledWith(message);
+  });
+
+  it("sends non-text bytes and transactions to the Wallet Standard wallet holding the address", async () => {
+    const wallet = mockWallet("Phantom", [account(owner)]);
+    registerWallet(mockWallet("Other", [account(other)]));
+    registerWallet(wallet);
+    const a = adapter();
+    const signer = injectedSolanaSigner(a);
+    await signer.signMessage(new Uint8Array([0xff, 0xfe]));
+    await signer.signTransaction(new Uint8Array([1]));
+    await signer.signAndSendTransaction?.(new Uint8Array([1]));
+    expect(a.signMessage).not.toHaveBeenCalled();
+    const features = wallet.features as Record<string, Record<string, ReturnType<typeof vi.fn>>>;
+    expect(features["solana:signMessage"].signMessage).toHaveBeenCalledOnce();
+    expect(features["solana:signTransaction"].signTransaction).toHaveBeenCalledOnce();
+    expect(features["solana:signAndSendTransaction"].signAndSendTransaction).toHaveBeenCalledOnce();
+  });
+
+  it("says which address has no transaction-capable wallet", async () => {
+    const signer = injectedSolanaSigner(adapter());
+    await expect(signer.signTransaction(new Uint8Array([1]))).rejects.toBeInstanceOf(
+      UnsupportedClientMethodError,
+    );
+    await expect(signer.signTransaction(new Uint8Array([1]))).rejects.toThrow(owner);
+  });
+});