@multiplatform.one/web3 7.33.0 → 7.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/web3",
-  "version": "7.33.0",
+  "version": "7.34.0",
   "description": "Web3 wallet integration for multiplatform.one ecosystem with ConnectKit and wagmi",
   "keywords": [
     "connectkit",
@@ -120,10 +120,11 @@
     "@aave/account": "^0.2.0",
     "@coinbase/wallet-sdk": "^4.3.6",
     "@metamask/connect-evm": "^2.1.1",
-    "@multiplatform.one/connectkit": "7.33.0",
-    "@multiplatform.one/gpg": "7.33.0",
-    "@multiplatform.one/platform": "7.33.0",
-    "@multiplatform.one/theme": "7.33.0",
+    "@multiplatform.one/connectkit": "7.34.0",
+    "@multiplatform.one/gpg": "7.34.0",
+    "@multiplatform.one/platform": "7.34.0",
+    "@multiplatform.one/theme": "7.34.0",
+    "@noble/ciphers": "^1.3.0",
     "@noble/curves": "^1.9.7",
     "@solana/kit": "^8.3.0",
     "@solana/wallet-adapter-base": "^0.9.27",
@@ -145,7 +146,7 @@
     "wagmi": "^3.7.1"
   },
   "devDependencies": {
-    "@multiplatform.one/config": "7.33.0",
+    "@multiplatform.one/config": "7.34.0",
     "@tamagui/build": "2.7.6",
     "@tanstack/react-query": "^5.100.7",
     "@testing-library/jest-dom": "^6.9.1",

package/src/connectkit/connectors/metaMaskConnectConnector.spec.ts

@@ -339,6 +339,50 @@ describe("metaMaskConnect under wagmi", () => {
     expect(request.mock.calls.map(([call]) => call.method)).toContain("personal_sign");
   });
 
+  it("signs under mainnet's scope when the desktop extension sits on a chain the app does not list", async () => {
+    // As @metamask/connect-evm's EIP1193Provider: the scope comes from
+    // selectedChainId before the first await, and a chain outside
+    // supportedNetworks is refused there.
+    const scopes: string[] = [];
+    const provider = {
+      selectedChainId: "0x2105" as string | undefined,
+      request: vi.fn(({ method }: { method: string }) => {
+        const chainId = provider.selectedChainId!;
+        const { api } = createEVMClient.mock.calls[0]![0] as {
+          api: { supportedNetworks: Record<string, string> };
+        };
+        if (!api.supportedNetworks[chainId])
+          return Promise.reject(
+            new Error(`Chain eip155:${Number(chainId)} is not configured in supportedNetworks`),
+          );
+        scopes.push(`eip155:${Number(chainId)}`);
+        return Promise.resolve(method === "personal_sign" ? "0x5167" : "0xabc");
+      }),
+    };
+    client.getChainId.mockImplementation(() => provider.selectedChainId!);
+    client.getProvider.mockReturnValue(provider as never);
+    client.connect.mockImplementationOnce(async () => ({ accounts: [first], chainId: "0x1" }));
+    const config = createConfig({
+      chains: [polygon, mainnet],
+      connectors: [metaMaskConnect({ dapp: { name: "test", url: "https://example.test" } })],
+      transports: { [polygon.id]: http(), [mainnet.id]: http() },
+      multiInjectedProviderDiscovery: false,
+      storage: null,
+    });
+    await connect(config, { connector: config.connectors[0]! });
+    (await clientEvents()).chainChanged("0x2105");
+
+    const signature = await signMessage(config, { message: "prove it" });
+
+    expect(signature).toBe("0x5167");
+    expect(scopes).toEqual(["eip155:1"]);
+    expect(provider.selectedChainId).toBe("0x2105");
+    await expect(sendTransaction(config, { to: second, value: 1n, gas: 21000n })).rejects.toThrow();
+    expect(provider.request.mock.calls.map(([call]) => call.method)).not.toContain(
+      "eth_sendTransaction",
+    );
+  });
+
   it("sends no transaction or typed signature on mainnet for an app that does not list it", async () => {
     const request = vi.fn(async ({ method }: { method: string }) =>
       method === "eth_chainId" ? "0x1" : "0xabc",

package/src/connectkit/connectors/metaMaskConnectConnector.ts

@@ -115,20 +115,45 @@ const offListMethods = new Set([
   "wallet_registerOnboarding",
 ]);
 
+/**
+ * MetaMask Connect scopes a request to the provider's selected chain and refuses
+ * one outside supportedNetworks. The desktop extension moves that chain to
+ * wherever the user's MetaMask sits, Base say, so personal_sign there never
+ * reached the wallet (MPO-494). It goes under mainnet's scope instead, which
+ * MetaMask Connect adds to every session. The provider reads the scope before
+ * its first await, so the selected chain is put back before anything else runs.
+ */
+function signUnderMainnet(
+  provider: EIP1193Provider,
+  args: { method: string; params?: unknown },
+): Promise<unknown> {
+  const selected = provider.selectedChainId;
+  provider.selectedChainId = numberToHex(mainnet.id);
+  try {
+    return provider.request(args as never);
+  } finally {
+    provider.selectedChainId = selected;
+  }
+}
+
 function listedChainsOnly(
   provider: EIP1193Provider,
   mm: MetamaskConnectEVM,
   networks: Record<Hex, string>,
+  supportedNetworks: Record<Hex, string>,
 ): EIP1193Provider {
   const request = (async (args: { method: string; params?: unknown }) => {
     const chainId = mm.getChainId();
-    if (chainId && !networks[numberToHex(Number(chainId))] && !offListMethods.has(args.method))
+    const current = chainId ? numberToHex(Number(chainId)) : undefined;
+    if (current && !networks[current] && !offListMethods.has(args.method))
       throw Object.assign(
         new Error(
           `MetaMask is on chain ${Number(chainId)}, which this app does not list, so ${args.method} was not sent`,
         ),
         { code: 4901 },
       );
+    if (current && !supportedNetworks[current] && args.method === "personal_sign")
+      return signUnderMainnet(provider, args);
     return provider.request(args as never);
   }) as EIP1193Provider["request"];
   return new Proxy(provider, {
@@ -383,7 +408,10 @@ export function metaMaskConnect(parameters: MetaMaskConnectParameters) {
         const mm = await claim();
         const provider = mm.getProvider();
         if (guarded?.provider !== provider)
-          guarded = { provider, wrapped: listedChainsOnly(provider, mm, networks) };
+          guarded = {
+            provider,
+            wrapped: listedChainsOnly(provider, mm, networks, supportedNetworks),
+          };
         return guarded.wrapped;
       },
       async isAuthorized() {

package/src/phantom/crypto.spec.ts

@@ -0,0 +1,61 @@
+import bs58 from "bs58";
+import { describe, expect, it } from "vitest";
+import {
+  boxKeyPairFromSecretKey,
+  decryptPayload,
+  encryptPayload,
+  generateBoxKeyPair,
+  PhantomDecryptError,
+  sharedSecret,
+} from "./crypto";
+
+const hex = (value: string) => Uint8Array.from(Buffer.from(value, "hex"));
+const toHex = (bytes: Uint8Array) => Buffer.from(bytes).toString("hex");
+
+// NaCl's crypto_box test keys; the expected values come from tweetnacl 1.0.3.
+const aliceSecret = hex("77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a");
+const bobPublic = hex("de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f");
+
+describe("phantom crypto", () => {
+  it("derives tweetnacl's box.before shared key", () => {
+    expect(toHex(sharedSecret(bobPublic, aliceSecret))).toBe(
+      "1b27556473e985d462cd51197a9a46c76009549eac6474f206c4ee0844f68389",
+    );
+  });
+
+  it("seals byte for byte like tweetnacl's box.after", () => {
+    const sealed = encryptPayload(
+      { a: 1 },
+      sharedSecret(bobPublic, aliceSecret),
+      new Uint8Array(24).fill(7),
+    );
+    expect(toHex(bs58.decode(sealed.payload))).toBe(
+      "a289826cda842719b07d6f10244b134793a8fb67d5bfdd",
+    );
+    expect(sealed.nonce).toBe(bs58.encode(new Uint8Array(24).fill(7)));
+  });
+
+  it("agrees on one secret from both sides and round-trips JSON", () => {
+    const dapp = generateBoxKeyPair();
+    const phantom = generateBoxKeyPair();
+    const dappSide = sharedSecret(phantom.publicKey, dapp.secretKey);
+    const phantomSide = sharedSecret(dapp.publicKey, phantom.secretKey);
+    expect(toHex(dappSide)).toBe(toHex(phantomSide));
+    const sealed = encryptPayload({ public_key: "abc", session: "s" }, phantomSide);
+    expect(decryptPayload(sealed.payload, sealed.nonce, dappSide)).toEqual({
+      public_key: "abc",
+      session: "s",
+    });
+  });
+
+  it("rebuilds the keypair from the stored secret key", () => {
+    const pair = generateBoxKeyPair();
+    expect(toHex(boxKeyPairFromSecretKey(pair.secretKey).publicKey)).toBe(toHex(pair.publicKey));
+  });
+
+  it("refuses a payload sealed for another key", () => {
+    const sealed = encryptPayload({ x: 1 }, sharedSecret(bobPublic, aliceSecret));
+    const other = sharedSecret(generateBoxKeyPair().publicKey, aliceSecret);
+    expect(() => decryptPayload(sealed.payload, sealed.nonce, other)).toThrow(PhantomDecryptError);
+  });
+});

package/src/phantom/crypto.ts

@@ -0,0 +1,88 @@
+import { hsalsa, xsalsa20poly1305 } from "@noble/ciphers/salsa";
+import { x25519 } from "@noble/curves/ed25519";
+import bs58 from "bs58";
+
+/** An x25519 keypair, the shape of tweetnacl's `box.keyPair()`. */
+export interface BoxKeyPair {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+}
+
+/** An encrypted payload as Phantom's deeplinks carry it: both fields base58. */
+export interface EncryptedPayload {
+  nonce: string;
+  payload: string;
+}
+
+export class PhantomDecryptError extends Error {
+  constructor(message = "could not decrypt Phantom's response with this session's key") {
+    super(message);
+    this.name = "PhantomDecryptError";
+  }
+}
+
+function randomBytes(length: number): Uint8Array {
+  const bytes = new Uint8Array(length);
+  globalThis.crypto.getRandomValues(bytes);
+  return bytes;
+}
+
+/** A fresh dapp keypair. Phantom recommends one per `connect`. */
+export function generateBoxKeyPair(): BoxKeyPair {
+  const secretKey = randomBytes(32);
+  return { secretKey, publicKey: x25519.getPublicKey(secretKey) };
+}
+
+export function boxKeyPairFromSecretKey(secretKey: Uint8Array): BoxKeyPair {
+  return { secretKey, publicKey: x25519.getPublicKey(secretKey) };
+}
+
+const sigma = new Uint32Array([0x61707865, 0x3320646e, 0x79622d32, 0x6b206574]);
+
+function toWords(bytes: Uint8Array): Uint32Array {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const words = new Uint32Array(bytes.length / 4);
+  for (let i = 0; i < words.length; i += 1) words[i] = view.getUint32(i * 4, true);
+  return words;
+}
+
+function fromWords(words: Uint32Array): Uint8Array {
+  const bytes = new Uint8Array(words.length * 4);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < words.length; i += 1) view.setUint32(i * 4, words[i], true);
+  return bytes;
+}
+
+/**
+ * tweetnacl's `box.before(theirPublicKey, mySecretKey)`: HSalsa20 of the
+ * x25519 shared point under a zero nonce. Phantom keys every payload of a
+ * session with it.
+ */
+export function sharedSecret(theirPublicKey: Uint8Array, mySecretKey: Uint8Array): Uint8Array {
+  const point = x25519.getSharedSecret(mySecretKey, theirPublicKey);
+  const out = new Uint32Array(8);
+  hsalsa(sigma, toWords(point), new Uint32Array(4), out);
+  return fromWords(out);
+}
+
+/** tweetnacl's `box.after`: XSalsa20-Poly1305 under the shared secret. */
+export function encryptPayload(
+  value: unknown,
+  secret: Uint8Array,
+  nonce: Uint8Array = randomBytes(24),
+): EncryptedPayload {
+  const plaintext = new TextEncoder().encode(JSON.stringify(value));
+  const sealed = xsalsa20poly1305(secret, nonce).encrypt(plaintext);
+  return { nonce: bs58.encode(nonce), payload: bs58.encode(sealed) };
+}
+
+/** tweetnacl's `box.open.after`, then JSON. Throws PhantomDecryptError on a bad tag. */
+export function decryptPayload<T = unknown>(data: string, nonce: string, secret: Uint8Array): T {
+  let opened: Uint8Array;
+  try {
+    opened = xsalsa20poly1305(secret, bs58.decode(nonce)).decrypt(bs58.decode(data));
+  } catch (error) {
+    throw Object.assign(new PhantomDecryptError(), { cause: error });
+  }
+  return JSON.parse(new TextDecoder().decode(opened)) as T;
+}

package/src/phantom/index.ts

@@ -1,7 +1,18 @@
-// `@multiplatform.one/web3/phantom`: Phantom's EVM wallet from a phone's own
-// browser. Phantom's deeplinks carry no EVM methods, so the page reopens in
-// Phantom's in-app browser (openInPhantom) and connects the provider Phantom
-// injects there (connectPhantomEvm).
+// `@multiplatform.one/web3/phantom`: Phantom from a phone's own browser,
+// with no relay. Phantom's deeplinks only carry Solana, so EVM goes
+// through Phantom's in-app browser (openInPhantom, then connectPhantomEvm on
+// the injected provider) and Solana through the encrypted deeplinks
+// (phantomDeeplink).
+export {
+  boxKeyPairFromSecretKey,
+  decryptPayload,
+  encryptPayload,
+  generateBoxKeyPair,
+  PhantomDecryptError,
+  sharedSecret,
+  type BoxKeyPair,
+  type EncryptedPayload,
+} from "./crypto";
 export {
   connectPhantomEvm,
   discoverPhantomEthereumProvider,
@@ -13,4 +24,26 @@ export {
   type OpenInPhantomOptions,
   type PhantomEthereumProvider,
 } from "./evm";
-export { phantomBrowseUrl, phantomUniversalLinkBase } from "./urls";
+export {
+  phantomDeeplink,
+  PhantomNotConnectedError,
+  sendSolanaTransaction,
+  type PhantomDeeplink,
+  type PhantomDeeplinkConfig,
+  type PhantomRedirectResult,
+  type PhantomSessionRecord,
+  type PhantomStorage,
+} from "./solana";
+export {
+  parsePhantomRedirect,
+  phantomBrowseUrl,
+  phantomConnectUrl,
+  phantomMethodUrl,
+  phantomUniversalLinkBase,
+  stripPhantomRedirect,
+  type PhantomCluster,
+  type PhantomConnectUrlParams,
+  type PhantomMethod,
+  type PhantomMethodUrlParams,
+  type PhantomRedirectParams,
+} from "./urls";

package/src/phantom/solana.spec.ts

@@ -0,0 +1,262 @@
+import bs58 from "bs58";
+import { describe, expect, it, vi } from "vitest";
+import {
+  decryptPayload,
+  encryptPayload,
+  generateBoxKeyPair,
+  PhantomDecryptError,
+  sharedSecret,
+  type BoxKeyPair,
+} from "./crypto";
+import {
+  phantomDeeplink,
+  PhantomNotConnectedError,
+  sendSolanaTransaction,
+  type PhantomStorage,
+} from "./solana";
+
+function memoryStorage(): PhantomStorage & { data: Map<string, string> } {
+  const data = new Map<string, string>();
+  return {
+    data,
+    getItem: (key) => data.get(key) ?? null,
+    setItem: (key, value) => void data.set(key, value),
+    removeItem: (key) => void data.delete(key),
+  };
+}
+
+/** Phantom's side of the protocol, as the docs describe it. */
+function fakePhantom() {
+  const wallet = "BSFtCudCd4pR4LSFqWPjbtXPKSNVbGkc35gRNdnqjMCU";
+  const session = "SessionToken1";
+  let keys: BoxKeyPair | undefined;
+  let secret: Uint8Array | undefined;
+  const answer = (redirect: string, extra: Record<string, string>) => {
+    const query = new URLSearchParams(extra);
+    return `${redirect}${redirect.includes("?") ? "?" : "?"}${query}`;
+  };
+  return {
+    wallet,
+    session,
+    approveConnect(link: string) {
+      const url = new URL(link);
+      keys = generateBoxKeyPair();
+      secret = sharedSecret(
+        bs58.decode(url.searchParams.get("dapp_encryption_public_key") ?? ""),
+        keys.secretKey,
+      );
+      const sealed = encryptPayload({ public_key: wallet, session }, secret);
+      return answer(url.searchParams.get("redirect_link") ?? "", {
+        phantom_encryption_public_key: bs58.encode(keys.publicKey),
+        nonce: sealed.nonce,
+        data: sealed.payload,
+      });
+    },
+    open(link: string) {
+      const url = new URL(link);
+      if (!secret) throw new Error("not connected");
+      return {
+        method: url.pathname.split("/").pop(),
+        redirect: url.searchParams.get("redirect_link") ?? "",
+        payload: decryptPayload<Record<string, unknown>>(
+          url.searchParams.get("payload") ?? "",
+          url.searchParams.get("nonce") ?? "",
+          secret,
+        ),
+      };
+    },
+    approve(redirect: string, data: Record<string, unknown>) {
+      if (!secret) throw new Error("not connected");
+      const sealed = encryptPayload(data, secret);
+      return answer(redirect, { nonce: sealed.nonce, data: sealed.payload });
+    },
+  };
+}
+
+function setup() {
+  const storage = memoryStorage();
+  const navigate = vi.fn<(url: string) => void>();
+  const config = {
+    appUrl: "https://app.example",
+    redirectLink: "https://app.example/pay?mobile=1",
+    cluster: "devnet" as const,
+    storage,
+    navigate,
+  };
+  return { storage, navigate, config, client: phantomDeeplink(config) };
+}
+
+describe("phantomDeeplink", () => {
+  it("navigates to connect synchronously, inside the tap", () => {
+    const { client, navigate } = setup();
+    const link = client.connect();
+    expect(navigate).toHaveBeenCalledTimes(1);
+    expect(navigate).toHaveBeenCalledWith(link);
+    expect(link.startsWith("https://phantom.com/ul/v1/connect?")).toBe(true);
+    expect(client.pending?.method).toBe("connect");
+  });
+
+  it("completes the handshake after a reload and signs a transaction", () => {
+    const phantom = fakePhantom();
+    const first = setup();
+    const back = phantom.approveConnect(first.client.connect());
+
+    // The page reloads on return: a new client over the same storage.
+    const client = phantomDeeplink(first.config);
+    expect(client.handleRedirect(back)).toEqual({
+      ok: true,
+      method: "connect",
+      publicKey: phantom.wallet,
+      session: phantom.session,
+    });
+    expect(client.connected).toBe(true);
+    expect(client.publicKey).toBe(phantom.wallet);
+    expect(client.pending).toBeUndefined();
+
+    const tx = Uint8Array.from([1, 2, 3, 4]);
+    const request = phantom.open(client.signTransaction(tx));
+    expect(request.method).toBe("signTransaction");
+    expect(request.redirect).toBe("https://app.example/pay?mobile=1");
+    expect(request.payload).toEqual({ transaction: bs58.encode(tx), session: phantom.session });
+
+    const signed = Uint8Array.from([9, 9, 9]);
+    const result = phantomDeeplink(first.config).handleRedirect(
+      phantom.approve(request.redirect, { transaction: bs58.encode(signed) }),
+    );
+    expect(result).toEqual({ ok: true, method: "signTransaction", transaction: signed });
+  });
+
+  it("signs a message and returns the signature bytes", () => {
+    const phantom = fakePhantom();
+    const { client } = setup();
+    client.handleRedirect(phantom.approveConnect(client.connect()));
+    const request = phantom.open(client.signMessage("hello", "utf8"));
+    expect(request.method).toBe("signMessage");
+    expect(request.payload).toEqual({
+      message: bs58.encode(new TextEncoder().encode("hello")),
+      display: "utf8",
+      session: phantom.session,
+    });
+    const signature = new Uint8Array(64).fill(5);
+    expect(
+      client.handleRedirect(
+        phantom.approve(request.redirect, { signature: bs58.encode(signature) }),
+      ),
+    ).toEqual({ ok: true, method: "signMessage", signature });
+  });
+
+  it("sends signAndSendTransaction with its options and returns the signature", () => {
+    const phantom = fakePhantom();
+    const { client } = setup();
+    client.handleRedirect(phantom.approveConnect(client.connect()));
+    const request = phantom.open(
+      client.signAndSendTransaction(Uint8Array.from([7]), { skipPreflight: true }),
+    );
+    expect(request.method).toBe("signAndSendTransaction");
+    expect(request.payload).toEqual({
+      transaction: bs58.encode(Uint8Array.from([7])),
+      sendOptions: { skipPreflight: true },
+      session: phantom.session,
+    });
+    expect(client.handleRedirect(phantom.approve(request.redirect, { signature: "SIG" }))).toEqual({
+      ok: true,
+      method: "signAndSendTransaction",
+      signature: "SIG",
+    });
+  });
+
+  it("reports a rejection and clears the pending request", () => {
+    const { client } = setup();
+    client.connect();
+    expect(
+      client.handleRedirect(
+        "https://app.example/pay?mobile=1?errorCode=4001&errorMessage=User%20rejected%20the%20request",
+      ),
+    ).toEqual({
+      ok: false,
+      method: "connect",
+      errorCode: "4001",
+      errorMessage: "User rejected the request",
+    });
+    expect(client.pending).toBeUndefined();
+  });
+
+  it("refuses to sign before connecting", () => {
+    const { client, navigate } = setup();
+    expect(() => client.signTransaction(Uint8Array.from([1]))).toThrow(PhantomNotConnectedError);
+    expect(navigate).not.toHaveBeenCalled();
+  });
+
+  it("throws on an answer sealed for another session", () => {
+    const phantom = fakePhantom();
+    const { client } = setup();
+    const back = phantom.approveConnect(client.connect());
+    client.connect();
+    expect(() => client.handleRedirect(back)).toThrow(PhantomDecryptError);
+  });
+
+  it("returns undefined for a page load with no answer", () => {
+    const { client } = setup();
+    expect(client.handleRedirect("https://app.example/pay?mobile=1")).toBeUndefined();
+  });
+
+  it("forgets the session locally on disconnect and tells Phantom", () => {
+    const phantom = fakePhantom();
+    const { client } = setup();
+    client.handleRedirect(phantom.approveConnect(client.connect()));
+    const request = phantom.open(client.disconnect());
+    expect(request.method).toBe("disconnect");
+    expect(request.payload).toEqual({ session: phantom.session });
+    expect(client.connected).toBe(false);
+  });
+
+  it("defaults the redirect to this page without Phantom's parameters", () => {
+    const storage = memoryStorage();
+    const navigate = vi.fn<(url: string) => void>();
+    vi.stubGlobal("location", { href: "https://app.example/pay?mobile=1?nonce=a&data=b#x" });
+    try {
+      const link = phantomDeeplink({ appUrl: "https://app.example", storage, navigate }).connect();
+      expect(new URL(link).searchParams.get("redirect_link")).toBe(
+        "https://app.example/pay?mobile=1#x",
+      );
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+});
+
+describe("sendSolanaTransaction", () => {
+  it("posts the signed bytes as base64 and returns the signature", async () => {
+    const fetch = vi.fn(
+      async () => new Response(JSON.stringify({ jsonrpc: "2.0", id: 1, result: "SIG" })),
+    );
+    await expect(
+      sendSolanaTransaction("https://api.devnet.solana.com", Uint8Array.from([1, 2, 255]), {
+        fetch,
+      }),
+    ).resolves.toBe("SIG");
+    const init = (fetch.mock.calls[0] as unknown as [string, RequestInit])[1];
+    expect(JSON.parse(String(init.body))).toEqual({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: ["AQL/", { encoding: "base64", skipPreflight: false }],
+    });
+  });
+
+  it("throws the RPC error", async () => {
+    const fetch = vi.fn(
+      async () =>
+        new Response(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            error: { code: -32002, message: "blockhash not found" },
+          }),
+        ),
+    );
+    await expect(
+      sendSolanaTransaction("https://rpc", Uint8Array.from([1]), { fetch }),
+    ).rejects.toMatchObject({ code: -32002 });
+  });
+});