@multiplatform.one/web3 7.33.1 → 7.34.1

package/dist/jsx/phantom/urls.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["__defProp","Object","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__hasOwnProp","prototype","hasOwnProperty"],"sources":["../../../src/phantom/urls.ts"],"sourcesContent":[null],"mappings":"AACO,YAAM;;AAON,IAAAA,SAAS,GAAAC,MAAA,CAAAC,cAGd;AAEA,IAAAC,gBAAc,GAAAF,MAAQ,CAAAG,wBAAQ;AAC9B,IAAAC,iBAAc,GAAAJ,MAAW,CAAAK,mBAAuB;AAClD,IAAAC,YAAA,GAAAN,MAAA,CAAAO,SAAA,CAAAC,cAAA","ignoreList":[]}
+{"version":3,"names":["__create","Object","create","__defProp","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__getProtoOf","getPrototypeOf","__hasOwnProp","prototype","hasOwnProperty","__export","target","all","name","get","enumerable","__copyProps","to","from","except","desc","key","call","__toESM","mod","isNodeMode","__esModule","value","__toCommonJS","urls_exports","parsePhantomRedirect","phantomBrowseUrl","phantomConnectUrl","phantomMethodUrl","phantomUniversalLinkBase","stripPhantomRedirect","module","exports","import_bs58","require","import_crypto","base","base2","override","replace","url","ref","options","arguments","length","encodeURIComponent","params","query","URLSearchParams","app_url","appUrl","dapp_encryption_public_key","default","encode","dappEncryptionPublicKey","redirect_link","redirectLink","cluster","set","sealed","encryptPayload","payload","session","sharedSecret","nonce"],"sources":["../../../src/phantom/urls.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/web3",
-  "version": "7.33.1",
+  "version": "7.34.1",
   "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.1",
-    "@multiplatform.one/gpg": "7.33.1",
-    "@multiplatform.one/platform": "7.33.1",
-    "@multiplatform.one/theme": "7.33.1",
+    "@multiplatform.one/connectkit": "7.34.1",
+    "@multiplatform.one/gpg": "7.34.1",
+    "@multiplatform.one/platform": "7.34.1",
+    "@multiplatform.one/theme": "7.34.1",
+    "@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.1",
+    "@multiplatform.one/config": "7.34.1",
     "@tamagui/build": "2.7.6",
     "@tanstack/react-query": "^5.100.7",
     "@testing-library/jest-dom": "^6.9.1",

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 });
+  });
+});