@multiplatform.one/web3 7.88.8 → 7.88.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/web3",
-  "version": "7.88.8",
+  "version": "7.88.9",
   "description": "Web3 wallet integration for multiplatform.one ecosystem with ConnectKit and wagmi",
   "keywords": [
     "connectkit",
@@ -120,10 +120,10 @@
     "@aave/account": "^0.2.1",
     "@coinbase/wallet-sdk": "^4.4.0",
     "@metamask/connect-evm": "^2.1.1",
-    "@multiplatform.one/connectkit": "^7.88.8",
-    "@multiplatform.one/gpg": "^7.88.8",
-    "@multiplatform.one/platform": "^7.88.8",
-    "@multiplatform.one/theme": "^7.88.8",
+    "@multiplatform.one/connectkit": "^7.88.9",
+    "@multiplatform.one/gpg": "^7.88.9",
+    "@multiplatform.one/platform": "^7.88.9",
+    "@multiplatform.one/theme": "^7.88.9",
     "@noble/ciphers": "^1.3.0",
     "@noble/curves": "^1.9.7",
     "@phosphor-icons/react": "^2.1.10",
@@ -147,8 +147,8 @@
     "wagmi": "^3.7.1"
   },
   "devDependencies": {
-    "@multiplatform.one/config": "7.88.8",
-    "@multiplatform.one/test-utils": "7.88.8",
+    "@multiplatform.one/config": "7.88.9",
+    "@multiplatform.one/test-utils": "7.88.9",
     "@tamagui/build": "2.7.6",
     "@tanstack/react-query": "^5.104.3",
     "@testing-library/jest-dom": "^7.0.1",

package/src/phantom/solana.spec.ts

@@ -225,6 +225,110 @@ describe("phantomDeeplink", () => {
   });
 });
 
+describe("phantomDeeplink answers and edges", () => {
+  function connected() {
+    const phantom = fakePhantom();
+    const ctx = setup();
+    ctx.client.handleRedirect(phantom.approveConnect(ctx.client.connect()));
+    return { phantom, ...ctx };
+  }
+
+  it("signs every transaction in one trip and returns each signed copy", () => {
+    const { phantom, client } = connected();
+    const txs = [Uint8Array.from([1]), Uint8Array.from([2, 3])];
+    const request = phantom.open(client.signAllTransactions(txs));
+    expect(request.method).toBe("signAllTransactions");
+    expect(request.payload).toEqual({
+      transactions: txs.map((tx) => bs58.encode(tx)),
+      session: phantom.session,
+    });
+    const signed = [Uint8Array.from([8]), Uint8Array.from([9, 9])];
+    expect(
+      client.handleRedirect(
+        phantom.approve(request.redirect, { transactions: signed.map((tx) => bs58.encode(tx)) }),
+      ),
+    ).toEqual({ ok: true, method: "signAllTransactions", transactions: signed });
+    expect(client.pending).toBeUndefined();
+  });
+
+  it("sends a transaction without options and signs raw message bytes without a display", () => {
+    const { phantom, client } = connected();
+    expect(phantom.open(client.signAndSendTransaction(Uint8Array.from([4]))).payload).toEqual({
+      transaction: bs58.encode(Uint8Array.from([4])),
+      session: phantom.session,
+    });
+    const bytes = Uint8Array.from([0, 255]);
+    expect(phantom.open(client.signMessage(bytes)).payload).toEqual({
+      message: bs58.encode(bytes),
+      session: phantom.session,
+    });
+  });
+
+  it("refuses an answer this browser holds no request for", () => {
+    const phantom = fakePhantom();
+    const other = setup();
+    const back = phantom.approveConnect(other.client.connect());
+    const { client } = setup();
+    expect(client.handleRedirect(back)).toEqual({
+      ok: false,
+      method: undefined,
+      errorCode: "-32603",
+      errorMessage: "Phantom answered, but this browser holds no matching request",
+    });
+  });
+
+  it("refuses a connect answer that carries no encryption key", () => {
+    const phantom = fakePhantom();
+    const { client } = setup();
+    const back = new URL(
+      phantom.approveConnect(client.connect()).replace("?mobile=1?", "?mobile=1&"),
+    );
+    back.searchParams.delete("phantom_encryption_public_key");
+    expect(client.handleRedirect(back.toString())).toMatchObject({
+      ok: false,
+      method: "connect",
+      errorMessage: "Phantom's answer carries no encryption key",
+    });
+  });
+
+  it("refuses an answer to a request it did not make", () => {
+    const { phantom, client, storage, config } = connected();
+    const [key] = [...storage.data.keys()];
+    const record = JSON.parse(storage.data.get(key)!);
+    storage.data.set(key, JSON.stringify({ ...record, pending: { method: "teleport", at: 1 } }));
+    expect(
+      phantomDeeplink(config).handleRedirect(phantom.approve(config.redirectLink, { ok: 1 })),
+    ).toMatchObject({
+      ok: false,
+      method: "teleport",
+      errorMessage: "Phantom answered a request this browser did not make",
+    });
+    expect(client.connected).toBe(true);
+  });
+
+  it("treats an unreadable stored session as none, and forget drops it", () => {
+    const { client, storage } = connected();
+    const [key] = [...storage.data.keys()];
+    client.forget();
+    expect(storage.data.has(key)).toBe(false);
+    storage.data.set(key, "{not json");
+    expect(client.connected).toBe(false);
+  });
+
+  it("asks for storage and a location when the page has neither", () => {
+    vi.stubGlobal("localStorage", undefined);
+    vi.stubGlobal("location", undefined);
+    try {
+      const client = phantomDeeplink({ appUrl: "https://app.example", navigate: vi.fn() });
+      expect(() => client.connect()).toThrow(/pass `redirectLink`|pass `storage`/);
+      expect(() => client.handleRedirect()).toThrow(/no location here/);
+      expect(() => client.forget()).toThrow(/no localStorage here/);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+});
+
 describe("sendSolanaTransaction", () => {
   it("posts the signed bytes as base64 and returns the signature", async () => {
     const fetch = vi.fn(