@multiplatform.one/web3 5.0.27

package/src/bridge/BridgeClient.ts

@@ -0,0 +1,121 @@
+import {
+  isBridgeMessage,
+  newRequestId,
+  type BridgeError,
+  type BridgeMessage,
+  type Namespace,
+} from "./protocol";
+import type { Transport } from "./transport";
+
+export interface RequestOptions {
+  /** Override the default timeout for this call. Sign/tx use a long value (user is in the wallet). */
+  timeoutMs?: number;
+  /** Reject the pending request when this fires (e.g. modal dismissed). */
+  signal?: AbortSignal;
+}
+
+export type EventHandler = (ns: Namespace, method: string, params: unknown) => void;
+
+interface Pending {
+  resolve: (value: unknown) => void;
+  reject: (reason: Error) => void;
+  cleanup: () => void;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000; // sign/tx can sit while the user is in the wallet app
+
+export class BridgeClient {
+  private readonly pending = new Map<string, Pending>();
+  private readonly listeners = new Set<EventHandler>();
+  private readonly unsubscribe: () => void;
+  private disposed = false;
+
+  constructor(
+    private readonly transport: Transport,
+    private readonly opts: { timeoutMs?: number } = {},
+  ) {
+    this.unsubscribe = transport.subscribe(this.onMessage);
+  }
+
+  request(ns: Namespace, method: string, params?: unknown, options: RequestOptions = {}): Promise<unknown> {
+    if (this.disposed) return Promise.reject(new Error("BridgeClient disposed"));
+    const id = newRequestId();
+    const timeoutMs = options.timeoutMs ?? this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise<unknown>((resolve, reject) => {
+      const onAbort = () => this.settle(id, reject, new Error("Request aborted"));
+      const timer =
+        timeoutMs > 0
+          ? setTimeout(
+              () => this.settle(id, reject, new Error(`Request timed out: ${ns}.${method}`)),
+              timeoutMs,
+            )
+          : undefined;
+      const cleanup = () => {
+        if (timer) clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+      };
+      this.pending.set(id, { resolve, reject, cleanup });
+      if (options.signal) {
+        if (options.signal.aborted) {
+          onAbort();
+          return;
+        }
+        options.signal.addEventListener("abort", onAbort, { once: true });
+      }
+      this.transport.post({ id, ns, kind: "req", method, params });
+    });
+  }
+
+  /** Subscribe to webview->native push events. Returns an unsubscribe fn. */
+  on(handler: EventHandler): () => void {
+    this.listeners.add(handler);
+    return () => {
+      this.listeners.delete(handler);
+    };
+  }
+
+  /** Reject all in-flight requests — call on WebView reload/crash. */
+  dispose(): void {
+    this.disposed = true;
+    this.unsubscribe();
+    for (const [, p] of this.pending) {
+      p.cleanup();
+      p.reject(new Error("Bridge disposed"));
+    }
+    this.pending.clear();
+    this.listeners.clear();
+  }
+
+  private settle(id: string, reject: (e: Error) => void, error: Error): void {
+    const p = this.pending.get(id);
+    if (!p) return;
+    this.pending.delete(id);
+    p.cleanup();
+    reject(error);
+  }
+
+  private readonly onMessage = (message: BridgeMessage): void => {
+    if (!isBridgeMessage(message)) return; // drop malformed
+    if (message.kind === "res") {
+      if (!message.id) return;
+      const p = this.pending.get(message.id);
+      if (!p) return; // unknown id -> ignore
+      this.pending.delete(message.id);
+      p.cleanup();
+      if (message.error) p.reject(toError(message.error));
+      else p.resolve(message.result);
+      return;
+    }
+    if (message.kind === "event" && message.method) {
+      // snapshot: a listener may (un)subscribe during dispatch
+      for (const l of Array.from(this.listeners)) l(message.ns, message.method, message.params);
+    }
+    // req on the client side is not expected; ignore
+  };
+}
+
+function toError(e: BridgeError): Error {
+  const err = new Error(e.message) as Error & { code?: number };
+  err.code = e.code;
+  return err;
+}

package/src/bridge/BridgeHost.spec.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it, vi } from "vitest";
+import { BridgeClient } from "./BridgeClient";
+import { BridgeHost } from "./BridgeHost";
+import { createMemoryTransportPair } from "./transport";
+
+/** Pair a native client (a) with a webview host (b) over the in-memory transport. */
+function pair() {
+  const { a, b } = createMemoryTransportPair();
+  const client = new BridgeClient(a);
+  const host = new BridgeHost(b);
+  return { client, host };
+}
+
+describe("BridgeHost", () => {
+  it("routes a req to the namespace handler and replies with its result", async () => {
+    const { client, host } = pair();
+    host.register("evm", (method) => (method === "eth_chainId" ? "0x1" : null));
+    await expect(client.request("evm", "eth_chainId")).resolves.toBe("0x1");
+  });
+
+  it("awaits async handlers", async () => {
+    const { client, host } = pair();
+    host.register("solana", async (method, params) => {
+      expect(method).toBe("signMessage");
+      return { signature: "c2ln", account: params };
+    });
+    await expect(client.request("solana", "signMessage", "Fg..")).resolves.toEqual({
+      signature: "c2ln",
+      account: "Fg..",
+    });
+  });
+
+  it("maps a thrown error (with code) to the response error", async () => {
+    const { client, host } = pair();
+    host.register("evm", () => {
+      const err = new Error("User rejected") as Error & { code: number };
+      err.code = 4001;
+      throw err;
+    });
+    const p = client.request("evm", "personal_sign", ["0x.."]).catch((e: Error & { code?: number }) => e);
+    const e = (await p) as Error & { code?: number };
+    expect(e.message).toBe("User rejected");
+    expect(e.code).toBe(4001);
+  });
+
+  it("replies -32601 when no handler is registered for the namespace", async () => {
+    const { client } = pair(); // host has no handlers
+    await expect(client.request("evm", "eth_chainId")).rejects.toThrow(/No handler for namespace: evm/);
+  });
+
+  it("emit() pushes an event the client receives", () => {
+    const { client, host } = pair();
+    const seen: Array<[string, string, unknown]> = [];
+    client.on((ns, method, params) => seen.push([ns, method, params]));
+    host.emit("evm", "accountsChanged", ["0xabc"]);
+    expect(seen).toEqual([["evm", "accountsChanged", ["0xabc"]]]);
+  });
+
+  it("ready() emits a sys ready event", () => {
+    const { client, host } = pair();
+    const onReady = vi.fn();
+    client.on((ns, method) => {
+      if (ns === "sys" && method === "ready") onReady();
+    });
+    host.ready();
+    expect(onReady).toHaveBeenCalledOnce();
+  });
+});

package/src/bridge/BridgeHost.ts

@@ -0,0 +1,72 @@
+import { isBridgeMessage, type BridgeError, type BridgeMessage, type Namespace } from "./protocol";
+import type { Transport } from "./transport";
+
+/**
+ * A per-namespace request handler. It owns its method vocabulary — unknown
+ * methods should throw (mapped to an error response), which IS the per-channel
+ * allow-list. EVM's handler proxies to the wallet provider's EIP-1193 `request`;
+ * Solana's handler dispatches wallet-standard ops.
+ */
+export type RequestHandler = (method: string, params: unknown) => Promise<unknown> | unknown;
+
+/**
+ * The in-WebView side of the bridge. Receives `req` from native, routes to the
+ * handler registered for the message's namespace, and replies with `res`. Pushes
+ * `event`s (connection lifecycle, modal open/close) and signals `ready`.
+ */
+export class BridgeHost {
+  private readonly handlers = new Map<Namespace, RequestHandler>();
+  private readonly unsubscribe: () => void;
+
+  constructor(private readonly transport: Transport) {
+    this.unsubscribe = transport.subscribe(this.onMessage);
+  }
+
+  register(ns: Namespace, handler: RequestHandler): void {
+    this.handlers.set(ns, handler);
+  }
+
+  /** Push a webview->native event (no response expected). */
+  emit(ns: Namespace, method: string, params?: unknown): void {
+    this.transport.post({ ns, kind: "event", method, params });
+  }
+
+  /** Tell native the host is initialized. */
+  ready(): void {
+    this.transport.post({ ns: "sys", kind: "event", method: "ready" });
+  }
+
+  dispose(): void {
+    this.unsubscribe();
+    this.handlers.clear();
+  }
+
+  private readonly onMessage = (message: BridgeMessage): void => {
+    if (!isBridgeMessage(message) || message.kind !== "req" || !message.id || !message.method) return;
+    const { id, ns, method } = message as { id: string; ns: Namespace; method: string };
+    const handler = this.handlers.get(ns);
+    if (!handler) {
+      this.reply(id, ns, undefined, { code: -32601, message: `No handler for namespace: ${ns}` });
+      return;
+    }
+    Promise.resolve()
+      .then(() => handler(method, message.params))
+      .then((result) => this.reply(id, ns, result))
+      .catch((e: unknown) => this.reply(id, ns, undefined, toBridgeError(e)));
+  };
+
+  private reply(id: string, ns: Namespace, result?: unknown, error?: BridgeError): void {
+    this.transport.post({ id, ns, kind: "res", result, error });
+  }
+}
+
+function toBridgeError(e: unknown): BridgeError {
+  if (e && typeof e === "object") {
+    const o = e as { code?: unknown; message?: unknown };
+    return {
+      code: typeof o.code === "number" ? o.code : -32000,
+      message: typeof o.message === "string" ? o.message : String(e),
+    };
+  }
+  return { code: -32000, message: String(e) };
+}

package/src/bridge/SolanaBridge.spec.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { base64ToBytes, bytesToBase64 } from "./base64";
+import { BridgeClient } from "./BridgeClient";
+import { BridgeHost } from "./BridgeHost";
+import { SolanaBridge } from "./SolanaBridge";
+import { createMemoryTransportPair } from "./transport";
+
+function setup() {
+  const { a, b } = createMemoryTransportPair();
+  const client = new BridgeClient(a);
+  const host = new BridgeHost(b);
+  return { client, host, solana: new SolanaBridge(client) };
+}
+
+describe("SolanaBridge", () => {
+  it("connect returns the publicKey from the host", async () => {
+    const { host, solana } = setup();
+    host.register("solana", (method) => (method === "connect" ? { publicKey: "Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS" } : null));
+    await expect(solana.connect()).resolves.toEqual({
+      publicKey: "Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS",
+    });
+  });
+
+  it("signMessage sends base64 and decodes the base64 signature back to bytes", async () => {
+    const { host, solana } = setup();
+    const message = new TextEncoder().encode("Sign in to multiplatform.one");
+    const signature = new Uint8Array(64).map((_, i) => (i * 3) % 256);
+    host.register("solana", (method, params) => {
+      expect(method).toBe("signMessage");
+      // host receives base64; decoding it must reproduce the original message bytes
+      const got = base64ToBytes((params as { message: string }).message);
+      expect(Array.from(got)).toEqual(Array.from(message));
+      return { signature: bytesToBase64(signature) };
+    });
+    const result = await solana.signMessage(message);
+    expect(Array.from(result)).toEqual(Array.from(signature));
+  });
+
+  it("signAllTransactions round-trips a list of byte buffers", async () => {
+    const { host, solana } = setup();
+    const txs = [new Uint8Array([1, 2, 3]), new Uint8Array([250, 0, 255, 9])];
+    host.register("solana", (method, params) => {
+      expect(method).toBe("signAllTransactions");
+      const list = (params as { transactions: string[] }).transactions;
+      // echo each back signed (here: identity, to assert transport fidelity)
+      return { transactions: list };
+    });
+    const out = await solana.signAllTransactions(txs);
+    expect(out.map((b) => Array.from(b))).toEqual(txs.map((b) => Array.from(b)));
+  });
+
+  it("on() forwards only solana events (evm events are filtered out)", () => {
+    const { host, solana } = setup();
+    const seen: Array<[string, unknown]> = [];
+    solana.on((event, params) => seen.push([event, params]));
+    host.emit("solana", "accountChanged", { publicKey: "Fg..." });
+    host.emit("evm", "accountsChanged", ["0xabc"]);
+    expect(seen).toEqual([["accountChanged", { publicKey: "Fg..." }]]);
+  });
+
+  it("disconnect resolves", async () => {
+    const { host, solana } = setup();
+    host.register("solana", () => null);
+    await expect(solana.disconnect()).resolves.toBeUndefined();
+  });
+});

package/src/bridge/SolanaBridge.ts

@@ -0,0 +1,49 @@
+import { base64ToBytes, bytesToBase64 } from "./base64";
+import type { BridgeClient } from "./BridgeClient";
+
+/**
+ * Native-side proxy for the WebView's Solana wallet (wallet-adapter / Wallet
+ * Standard). Mirrors the operations `@solana/wallet-adapter-react`'s `useWallet`
+ * exposes; bytes (messages/transactions) cross the bridge as base64. The React
+ * context that adapts this to wallet-adapter's hook shape is wired in the native
+ * WalletProvider (later plan); this class is the testable transport core.
+ */
+export class SolanaBridge {
+  constructor(private readonly bridge: BridgeClient) {}
+
+  async connect(): Promise<{ publicKey: string }> {
+    return (await this.bridge.request("solana", "connect")) as { publicKey: string };
+  }
+
+  async disconnect(): Promise<void> {
+    await this.bridge.request("solana", "disconnect");
+  }
+
+  async signMessage(message: Uint8Array): Promise<Uint8Array> {
+    const res = (await this.bridge.request("solana", "signMessage", {
+      message: bytesToBase64(message),
+    })) as { signature: string };
+    return base64ToBytes(res.signature);
+  }
+
+  async signTransaction(transaction: Uint8Array): Promise<Uint8Array> {
+    const res = (await this.bridge.request("solana", "signTransaction", {
+      transaction: bytesToBase64(transaction),
+    })) as { transaction: string };
+    return base64ToBytes(res.transaction);
+  }
+
+  async signAllTransactions(transactions: Uint8Array[]): Promise<Uint8Array[]> {
+    const res = (await this.bridge.request("solana", "signAllTransactions", {
+      transactions: transactions.map(bytesToBase64),
+    })) as { transactions: string[] };
+    return res.transactions.map(base64ToBytes);
+  }
+
+  /** Subscribe to solana lifecycle events (connect/disconnect/accountChanged). */
+  on(handler: (event: string, params: unknown) => void): () => void {
+    return this.bridge.on((ns, method, params) => {
+      if (ns === "solana") handler(method, params);
+    });
+  }
+}

package/src/bridge/base64.spec.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { base64ToBytes, bytesToBase64 } from "./base64";
+
+const enc = (s: string) => new TextEncoder().encode(s);
+const dec = (b: Uint8Array) => new TextDecoder().decode(b);
+
+describe("base64", () => {
+  it("encodes known vectors (with padding)", () => {
+    expect(bytesToBase64(enc("hi"))).toBe("aGk=");
+    expect(bytesToBase64(enc("hello"))).toBe("aGVsbG8=");
+    expect(bytesToBase64(enc("foo"))).toBe("Zm9v");
+    expect(bytesToBase64(new Uint8Array([]))).toBe("");
+  });
+
+  it("decodes known vectors", () => {
+    expect(dec(base64ToBytes("aGk="))).toBe("hi");
+    expect(dec(base64ToBytes("aGVsbG8="))).toBe("hello");
+    expect(dec(base64ToBytes("Zm9v"))).toBe("foo");
+  });
+
+  it("round-trips arbitrary byte values 0..255", () => {
+    const bytes = new Uint8Array(256);
+    for (let i = 0; i < 256; i += 1) bytes[i] = i;
+    expect(Array.from(base64ToBytes(bytesToBase64(bytes)))).toEqual(Array.from(bytes));
+  });
+
+  it("round-trips a 64-byte signature-sized buffer", () => {
+    const sig = new Uint8Array(64);
+    for (let i = 0; i < 64; i += 1) sig[i] = (i * 7 + 3) % 256;
+    expect(Array.from(base64ToBytes(bytesToBase64(sig)))).toEqual(Array.from(sig));
+  });
+});

package/src/bridge/base64.ts

@@ -0,0 +1,40 @@
+// Pure-JS base64 for Uint8Array <-> string. No Buffer / atob / btoa so it works
+// identically under Hermes (React Native) and Node — the bridge serializes Solana
+// messages/transactions as base64 because postMessage can't carry Uint8Array.
+
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const LOOKUP: Record<string, number> = {};
+for (let i = 0; i < ALPHABET.length; i += 1) LOOKUP[ALPHABET[i]] = i;
+
+export function bytesToBase64(bytes: Uint8Array): string {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += ALPHABET[b0 >> 2];
+    out += ALPHABET[((b0 & 0x03) << 4) | (b1 >> 4)];
+    out += i + 1 < bytes.length ? ALPHABET[((b1 & 0x0f) << 2) | (b2 >> 6)] : "=";
+    out += i + 2 < bytes.length ? ALPHABET[b2 & 0x3f] : "=";
+  }
+  return out;
+}
+
+export function base64ToBytes(base64: string): Uint8Array {
+  const clean = base64.replace(/[^A-Za-z0-9+/]/g, "");
+  const byteLength = Math.floor((clean.length * 6) / 8);
+  const bytes = new Uint8Array(byteLength);
+  let acc = 0;
+  let bits = 0;
+  let p = 0;
+  for (let i = 0; i < clean.length; i += 1) {
+    acc = (acc << 6) | LOOKUP[clean[i]];
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes[p] = (acc >> bits) & 0xff;
+      p += 1;
+    }
+  }
+  return bytes;
+}

package/src/bridge/bridgeConnector.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it, vi } from "vitest";
+import { BridgeClient } from "./BridgeClient";
+import { BridgeHost } from "./BridgeHost";
+import { createBridgeConnector } from "./bridgeConnector";
+import { createMemoryTransportPair } from "./transport";
+
+/** Minimal wagmi connector `config` stub — we only assert emitter usage. */
+function stubConfig() {
+  return { emitter: { emit: vi.fn() }, chains: [], storage: null } as any;
+}
+
+function setup() {
+  const { a, b } = createMemoryTransportPair();
+  const client = new BridgeClient(a);
+  const host = new BridgeHost(b);
+  const config = stubConfig();
+  const connector = createBridgeConnector(client)(config);
+  return { host, connector, config };
+}
+
+describe("createBridgeConnector", () => {
+  it("exposes the wagmi connector contract", () => {
+    const { connector } = setup();
+    expect(connector.id).toBe("webViewBridge");
+    expect(connector.type).toBe("webViewBridge");
+    for (const m of ["connect", "disconnect", "getAccounts", "getChainId", "getProvider", "isAuthorized"] as const) {
+      expect(typeof connector[m]).toBe("function");
+    }
+  });
+
+  it("connect() requests accounts + chainId over the bridge", async () => {
+    const { host, connector } = setup();
+    host.register("evm", (method) => {
+      if (method === "eth_requestAccounts" || method === "eth_accounts") return ["0xAbC0000000000000000000000000000000000001"];
+      if (method === "eth_chainId") return "0x1";
+      return null;
+    });
+    const result = await connector.connect();
+    expect(result).toEqual({ accounts: ["0xAbC0000000000000000000000000000000000001"], chainId: 1 });
+  });
+
+  it("getChainId parses the hex chainId to a number", async () => {
+    const { host, connector } = setup();
+    host.register("evm", (method) => (method === "eth_chainId" ? "0x89" : null));
+    await expect(connector.getChainId()).resolves.toBe(137);
+  });
+
+  it("onAccountsChanged emits change (or disconnect when empty)", () => {
+    const { connector, config } = setup();
+    connector.onAccountsChanged(["0xdef"]);
+    expect(config.emitter.emit).toHaveBeenCalledWith("change", { accounts: ["0xdef"] });
+    connector.onAccountsChanged([]);
+    expect(config.emitter.emit).toHaveBeenCalledWith("disconnect");
+  });
+
+  it("isAuthorized is false when there are no accounts", async () => {
+    const { host, connector } = setup();
+    host.register("evm", (method) => (method === "eth_accounts" ? [] : null));
+    await expect(connector.isAuthorized()).resolves.toBe(false);
+  });
+});

package/src/bridge/bridgeConnector.ts

@@ -0,0 +1,88 @@
+import { createConnector } from "wagmi";
+import type { Address } from "viem";
+import type { BridgeClient } from "./BridgeClient";
+import { createBridgeProvider, type BridgeProvider } from "./eip1193";
+
+/**
+ * A wagmi connector whose provider is the bridge. Every wagmi hook
+ * (useAccount/useSignMessage/useSendTransaction/…) keeps working unchanged on
+ * native — wagmi only sees an ordinary EIP-1193 provider; the wallet lives in the
+ * WebView on the other side of the bridge.
+ */
+export function createBridgeConnector(bridge: BridgeClient) {
+  return createConnector((config) => {
+    let provider: BridgeProvider | undefined;
+
+    const getProvider = async (): Promise<BridgeProvider> => {
+      if (!provider) provider = createBridgeProvider(bridge);
+      return provider;
+    };
+
+    const connector = {
+      id: "webViewBridge",
+      name: "WebView Wallet",
+      type: "webViewBridge" as const,
+
+      async getProvider() {
+        return getProvider();
+      },
+
+      async getChainId() {
+        const p = await getProvider();
+        const hex = (await p.request({ method: "eth_chainId" })) as string;
+        return Number(hex);
+      },
+
+      async getAccounts() {
+        const p = await getProvider();
+        return (await p.request({ method: "eth_accounts" })) as readonly Address[];
+      },
+
+      async connect() {
+        const p = await getProvider();
+        const accounts = (await p.request({ method: "eth_requestAccounts" })) as readonly Address[];
+        const chainId = await connector.getChainId();
+        p.on("accountsChanged", connector.onAccountsChanged as ProviderEventListener);
+        p.on("chainChanged", connector.onChainChanged as ProviderEventListener);
+        p.on("disconnect", connector.onDisconnect as ProviderEventListener);
+        return { accounts, chainId };
+      },
+
+      async disconnect() {
+        const p = await getProvider();
+        p.removeListener("accountsChanged", connector.onAccountsChanged as ProviderEventListener);
+        p.removeListener("chainChanged", connector.onChainChanged as ProviderEventListener);
+        p.removeListener("disconnect", connector.onDisconnect as ProviderEventListener);
+        await p.request({ method: "wallet_disconnect" }).catch(() => undefined);
+      },
+
+      async isAuthorized() {
+        try {
+          return (await connector.getAccounts()).length > 0;
+        } catch {
+          return false;
+        }
+      },
+
+      onAccountsChanged(accounts: string[]) {
+        if (accounts.length === 0) config.emitter.emit("disconnect");
+        else config.emitter.emit("change", { accounts: accounts as readonly Address[] });
+      },
+
+      onChainChanged(chainId: string) {
+        config.emitter.emit("change", { chainId: Number(chainId) });
+      },
+
+      onDisconnect() {
+        config.emitter.emit("disconnect");
+      },
+    };
+
+    // wagmi's connect() is generic over EIP-5792 `withCapabilities`; this bridge
+    // connector intentionally doesn't support capabilities. The shape is otherwise
+    // exact and verified by bridgeConnector.spec.ts, so cast to wagmi's contract.
+    return connector as unknown as ReturnType<Parameters<typeof createConnector>[0]>;
+  });
+}
+
+type ProviderEventListener = (payload?: unknown) => void;

package/src/bridge/eip1193.spec.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it, vi } from "vitest";
+import { BridgeClient } from "./BridgeClient";
+import { BridgeHost } from "./BridgeHost";
+import { createBridgeProvider } from "./eip1193";
+import { createMemoryTransportPair } from "./transport";
+
+function setup() {
+  const { a, b } = createMemoryTransportPair();
+  const client = new BridgeClient(a);
+  const host = new BridgeHost(b);
+  return { client, host, provider: createBridgeProvider(client) };
+}
+
+describe("createBridgeProvider", () => {
+  it("forwards request() over the bridge as an evm call", async () => {
+    const { host, provider } = setup();
+    host.register("evm", (method, params) => {
+      expect(method).toBe("personal_sign");
+      expect(params).toEqual(["0xdeadbeef", "0xabc"]);
+      return "0xsignature";
+    });
+    await expect(provider.request({ method: "personal_sign", params: ["0xdeadbeef", "0xabc"] })).resolves.toBe(
+      "0xsignature",
+    );
+  });
+
+  it("delivers evm bridge events to matching EIP-1193 listeners", () => {
+    const { host, provider } = setup();
+    const onAccounts = vi.fn();
+    const onChain = vi.fn();
+    provider.on("accountsChanged", onAccounts);
+    provider.on("chainChanged", onChain);
+    host.emit("evm", "accountsChanged", ["0xabc"]);
+    host.emit("evm", "chainChanged", "0x89");
+    expect(onAccounts).toHaveBeenCalledWith(["0xabc"]);
+    expect(onChain).toHaveBeenCalledWith("0x89");
+  });
+
+  it("ignores non-evm events and respects removeListener", () => {
+    const { host, provider } = setup();
+    const l = vi.fn();
+    provider.on("accountsChanged", l);
+    host.emit("solana", "accountsChanged", ["should-not-fire"]);
+    provider.removeListener("accountsChanged", l);
+    host.emit("evm", "accountsChanged", ["0xabc"]);
+    expect(l).not.toHaveBeenCalled();
+  });
+});