@multiplatform.one/web3 7.33.1 → 7.34.0

package/src/phantom/solana.ts

@@ -0,0 +1,374 @@
+import bs58 from "bs58";
+import {
+  boxKeyPairFromSecretKey,
+  decryptPayload,
+  generateBoxKeyPair,
+  sharedSecret,
+} from "./crypto";
+import {
+  parsePhantomRedirect,
+  phantomConnectUrl,
+  phantomMethodUrl,
+  stripPhantomRedirect,
+  type PhantomCluster,
+  type PhantomMethod,
+} from "./urls";
+
+/** The slice of the Web Storage API the session needs. */
+export interface PhantomStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+/** What is kept between the tap and the return. Base58 throughout. */
+export interface PhantomSessionRecord {
+  dappSecretKey: string;
+  cluster?: PhantomCluster;
+  phantomEncryptionPublicKey?: string;
+  session?: string;
+  publicKey?: string;
+  pending?: { method: PhantomMethod; at: number };
+}
+
+export interface PhantomDeeplinkConfig {
+  /** Stored in Phantom's session and checked against its blocklist. */
+  appUrl: string;
+  /**
+   * Where Phantom returns. Defaults to the current page without Phantom's
+   * parameters. An https link shows the app's name and icon in Phantom and
+   * returns to the phone's browser; a custom scheme returns to an app, which
+   * must hand the URL to `handleRedirect` in a page with the same storage.
+   */
+  redirectLink?: string;
+  cluster?: PhantomCluster;
+  /**
+   * Must outlive the trip to Phantom: on Android the return can land in a new
+   * browser tab. Defaults to localStorage.
+   */
+  storage?: PhantomStorage;
+  storageKey?: string;
+  /** Defaults to `location.assign`. Called synchronously inside the request method. */
+  navigate?: (url: string) => void;
+  /** Overrides https://phantom.com/ul. */
+  base?: string;
+  now?: () => number;
+}
+
+export type PhantomRedirectResult =
+  | { ok: true; method: "connect"; publicKey: string; session: string }
+  | { ok: true; method: "signTransaction"; transaction: Uint8Array }
+  | { ok: true; method: "signAllTransactions"; transactions: Uint8Array[] }
+  | { ok: true; method: "signAndSendTransaction"; signature: string }
+  | { ok: true; method: "signMessage"; signature: Uint8Array }
+  | {
+      ok: false;
+      method: PhantomMethod | undefined;
+      errorCode: string;
+      errorMessage: string;
+    };
+
+type ConnectedRecord = PhantomSessionRecord & {
+  session: string;
+  phantomEncryptionPublicKey: string;
+};
+
+export class PhantomNotConnectedError extends Error {
+  constructor() {
+    super("no Phantom deeplink session: call connect() first");
+    this.name = "PhantomNotConnectedError";
+  }
+}
+
+export interface PhantomDeeplink {
+  /** The connected wallet's base58 address, once a connect has come back. */
+  readonly publicKey: string | undefined;
+  readonly connected: boolean;
+  /** The request still waiting for Phantom's answer, if any. */
+  readonly pending: PhantomSessionRecord["pending"];
+  /**
+   * Each request below builds its link from what is already stored and
+   * navigates before returning, with nothing awaited, so it runs inside the
+   * tap's user activation and the browser follows the link without asking.
+   * The link is returned too, for an `<a href>`.
+   */
+  connect(): string;
+  signTransaction(serializedTransaction: Uint8Array): string;
+  signAllTransactions(serializedTransactions: Uint8Array[]): string;
+  /** Deprecated by Phantom: prefer signTransaction and sendSolanaTransaction. */
+  signAndSendTransaction(
+    serializedTransaction: Uint8Array,
+    sendOptions?: Record<string, unknown>,
+  ): string;
+  signMessage(message: Uint8Array | string, display?: "utf8" | "hex"): string;
+  /** Forgets the session here at once, then tells Phantom. */
+  disconnect(): string;
+  /**
+   * Reads Phantom's answer off the return URL (the current one by default)
+   * and updates the stored session. Undefined when the URL carries none.
+   * Throws PhantomDecryptError when the answer was not sealed for this
+   * session's key.
+   */
+  handleRedirect(href?: string): PhantomRedirectResult | undefined;
+  /** Drops the stored keypair and session without asking Phantom. */
+  forget(): void;
+}
+
+const defaultStorageKey = "mpo.web3.phantom.deeplink";
+
+function defaultStorage(): PhantomStorage {
+  const storage = (globalThis as { localStorage?: PhantomStorage }).localStorage;
+  if (!storage) throw new Error("phantomDeeplink: no localStorage here; pass `storage`");
+  return storage;
+}
+
+function currentHref(): string {
+  const href = (globalThis as { location?: { href?: string } }).location?.href;
+  if (!href) throw new Error("phantomDeeplink: no location here; pass `redirectLink`");
+  return href;
+}
+
+/** A Solana wallet in the Phantom app, reached from a phone's browser through Phantom's encrypted deeplinks. */
+export function phantomDeeplink(config: PhantomDeeplinkConfig): PhantomDeeplink {
+  const storageKey = config.storageKey ?? defaultStorageKey;
+  const storage = () => config.storage ?? defaultStorage();
+  const now = config.now ?? Date.now;
+  const navigate =
+    config.navigate ??
+    ((url: string) => (globalThis as { location: Location }).location.assign(url));
+  const redirectLink = () => config.redirectLink ?? stripPhantomRedirect(currentHref());
+
+  const load = (): PhantomSessionRecord | undefined => {
+    const raw = storage().getItem(storageKey);
+    if (!raw) return undefined;
+    try {
+      return JSON.parse(raw) as PhantomSessionRecord;
+    } catch {
+      return undefined;
+    }
+  };
+  const save = (record: PhantomSessionRecord) =>
+    storage().setItem(storageKey, JSON.stringify(record));
+
+  const connected = (): ConnectedRecord => {
+    const record = load();
+    if (!record?.session || !record.phantomEncryptionPublicKey)
+      throw new PhantomNotConnectedError();
+    return record as ConnectedRecord;
+  };
+
+  const methodUrl = (
+    record: ConnectedRecord,
+    method: Exclude<PhantomMethod, "connect">,
+    payload: Record<string, unknown>,
+  ) => {
+    const keyPair = boxKeyPairFromSecretKey(bs58.decode(record.dappSecretKey));
+    return phantomMethodUrl({
+      method,
+      payload,
+      session: record.session,
+      dappEncryptionPublicKey: keyPair.publicKey,
+      sharedSecret: sharedSecret(bs58.decode(record.phantomEncryptionPublicKey), keyPair.secretKey),
+      redirectLink: redirectLink(),
+      base: config.base,
+    });
+  };
+
+  const request = (
+    method: Exclude<PhantomMethod, "connect" | "disconnect">,
+    payload: Record<string, unknown>,
+  ): string => {
+    const record = connected();
+    const url = methodUrl(record, method, payload);
+    save({ ...record, pending: { method, at: now() } });
+    navigate(url);
+    return url;
+  };
+
+  return {
+    get publicKey() {
+      return load()?.publicKey;
+    },
+    get connected() {
+      const record = load();
+      return !!(record?.session && record.phantomEncryptionPublicKey);
+    },
+    get pending() {
+      return load()?.pending;
+    },
+
+    connect() {
+      const keyPair = generateBoxKeyPair();
+      const url = phantomConnectUrl({
+        appUrl: config.appUrl,
+        dappEncryptionPublicKey: keyPair.publicKey,
+        redirectLink: redirectLink(),
+        cluster: config.cluster,
+        base: config.base,
+      });
+      save({
+        dappSecretKey: bs58.encode(keyPair.secretKey),
+        cluster: config.cluster,
+        pending: { method: "connect", at: now() },
+      });
+      navigate(url);
+      return url;
+    },
+
+    signTransaction(serializedTransaction) {
+      return request("signTransaction", { transaction: bs58.encode(serializedTransaction) });
+    },
+
+    signAllTransactions(serializedTransactions) {
+      return request("signAllTransactions", {
+        transactions: serializedTransactions.map((tx) => bs58.encode(tx)),
+      });
+    },
+
+    signAndSendTransaction(serializedTransaction, sendOptions) {
+      return request("signAndSendTransaction", {
+        transaction: bs58.encode(serializedTransaction),
+        ...(sendOptions ? { sendOptions } : {}),
+      });
+    },
+
+    signMessage(message, display) {
+      const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+      return request("signMessage", {
+        message: bs58.encode(bytes),
+        ...(display ? { display } : {}),
+      });
+    },
+
+    disconnect() {
+      const url = methodUrl(connected(), "disconnect", {});
+      storage().removeItem(storageKey);
+      navigate(url);
+      return url;
+    },
+
+    handleRedirect(href) {
+      const params = parsePhantomRedirect(href ?? currentHref());
+      if (!params) return undefined;
+      const record = load();
+      const method = record?.pending?.method;
+      if (params.errorCode) {
+        if (record) save({ ...record, pending: undefined });
+        return {
+          ok: false,
+          method,
+          errorCode: params.errorCode,
+          errorMessage: params.errorMessage ?? "",
+        };
+      }
+      if (!record || !params.data || !params.nonce) {
+        return {
+          ok: false,
+          method,
+          errorCode: "-32603",
+          errorMessage: "Phantom answered, but this browser holds no matching request",
+        };
+      }
+      const secretKey = bs58.decode(record.dappSecretKey);
+      const phantomKey =
+        method === "connect"
+          ? params.phantomEncryptionPublicKey
+          : record.phantomEncryptionPublicKey;
+      if (!phantomKey) {
+        return {
+          ok: false,
+          method,
+          errorCode: "-32603",
+          errorMessage: "Phantom's answer carries no encryption key",
+        };
+      }
+      const data = decryptPayload<Record<string, unknown>>(
+        params.data,
+        params.nonce,
+        sharedSecret(bs58.decode(phantomKey), secretKey),
+      );
+      switch (method) {
+        case "connect": {
+          const publicKey = String(data.public_key);
+          const session = String(data.session);
+          save({
+            ...record,
+            phantomEncryptionPublicKey: phantomKey,
+            publicKey,
+            session,
+            pending: undefined,
+          });
+          return { ok: true, method, publicKey, session };
+        }
+        case "signTransaction":
+          save({ ...record, pending: undefined });
+          return { ok: true, method, transaction: bs58.decode(String(data.transaction)) };
+        case "signAllTransactions":
+          save({ ...record, pending: undefined });
+          return {
+            ok: true,
+            method,
+            transactions: (data.transactions as string[]).map((tx) => bs58.decode(tx)),
+          };
+        case "signAndSendTransaction":
+          save({ ...record, pending: undefined });
+          return { ok: true, method, signature: String(data.signature) };
+        case "signMessage":
+          save({ ...record, pending: undefined });
+          return { ok: true, method, signature: bs58.decode(String(data.signature)) };
+        default:
+          return {
+            ok: false,
+            method,
+            errorCode: "-32603",
+            errorMessage: "Phantom answered a request this browser did not make",
+          };
+      }
+    },
+
+    forget() {
+      storage().removeItem(storageKey);
+    },
+  };
+}
+
+function toBase64(bytes: Uint8Array): string {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+/**
+ * Broadcasts a transaction Phantom signed (signTransaction's answer) through
+ * a Solana JSON-RPC endpoint and returns its base58 signature.
+ */
+export async function sendSolanaTransaction(
+  rpcUrl: string,
+  signedTransaction: Uint8Array,
+  options: { skipPreflight?: boolean; fetch?: typeof fetch } = {},
+): Promise<string> {
+  const response = await (options.fetch ?? fetch)(rpcUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [
+        toBase64(signedTransaction),
+        { encoding: "base64", skipPreflight: options.skipPreflight ?? false },
+      ],
+    }),
+  });
+  const body = (await response.json()) as {
+    result?: string;
+    error?: { code: number; message: string };
+  };
+  if (body.error) {
+    throw Object.assign(new Error(`sendTransaction failed: ${body.error.message}`), {
+      code: body.error.code,
+    });
+  }
+  if (typeof body.result !== "string") throw new Error("sendTransaction returned no signature");
+  return body.result;
+}

package/src/phantom/urls.spec.ts

@@ -1,7 +1,15 @@
+import bs58 from "bs58";
 import { describe, expect, it } from "vitest";
-import { phantomBrowseUrl } from "./urls";
+import { decryptPayload, generateBoxKeyPair, sharedSecret } from "./crypto";
+import {
+  parsePhantomRedirect,
+  phantomBrowseUrl,
+  phantomConnectUrl,
+  phantomMethodUrl,
+  stripPhantomRedirect,
+} from "./urls";
 
-describe("phantomBrowseUrl", () => {
+describe("phantom urls", () => {
   it("builds the browse link Phantom documents", () => {
     expect(
       phantomBrowseUrl(
@@ -14,16 +22,99 @@ describe("phantomBrowseUrl", () => {
   });
 
   it("keeps a page's own query inside the browse link", () => {
+    const link = phantomBrowseUrl(
+      "https://dev.promanager.vip/u/buy?mobile=1&x=a b",
+      "https://dev.promanager.vip",
+      {
+        base: "https://phantom.app/ul/",
+      },
+    );
+    expect(link).toBe(
+      "https://phantom.app/ul/browse/https%3A%2F%2Fdev.promanager.vip%2Fu%2Fbuy%3Fmobile%3D1%26x%3Da%20b?ref=https%3A%2F%2Fdev.promanager.vip",
+    );
+  });
+
+  it("builds connect with the dapp key in base58", () => {
+    const pair = generateBoxKeyPair();
+    const url = new URL(
+      phantomConnectUrl({
+        appUrl: "https://app.example",
+        dappEncryptionPublicKey: pair.publicKey,
+        redirectLink: "https://app.example/pay?mobile=1",
+        cluster: "devnet",
+      }),
+    );
+    expect(`${url.origin}${url.pathname}`).toBe("https://phantom.com/ul/v1/connect");
+    expect(Object.fromEntries(url.searchParams)).toEqual({
+      app_url: "https://app.example",
+      dapp_encryption_public_key: bs58.encode(pair.publicKey),
+      redirect_link: "https://app.example/pay?mobile=1",
+      cluster: "devnet",
+    });
+  });
+
+  it("seals a method's payload with the session for Phantom to open", () => {
+    const dapp = generateBoxKeyPair();
+    const phantom = generateBoxKeyPair();
+    const url = new URL(
+      phantomMethodUrl({
+        method: "signTransaction",
+        payload: { transaction: "3xyz" },
+        session: "sess",
+        dappEncryptionPublicKey: dapp.publicKey,
+        sharedSecret: sharedSecret(phantom.publicKey, dapp.secretKey),
+        redirectLink: "myapp://done",
+      }),
+    );
+    expect(url.pathname).toBe("/ul/v1/signTransaction");
+    expect([...url.searchParams.keys()]).toEqual([
+      "dapp_encryption_public_key",
+      "nonce",
+      "redirect_link",
+      "payload",
+    ]);
+    expect(url.searchParams.get("dapp_encryption_public_key")).toBe(bs58.encode(dapp.publicKey));
+    expect(bs58.decode(url.searchParams.get("nonce") ?? "")).toHaveLength(24);
     expect(
-      phantomBrowseUrl(
-        "https://dev.promanager.vip/u/buy?mobile=1&x=a b",
-        "https://dev.promanager.vip",
-        {
-          base: "https://phantom.app/ul/",
-        },
+      decryptPayload(
+        url.searchParams.get("payload") ?? "",
+        url.searchParams.get("nonce") ?? "",
+        sharedSecret(dapp.publicKey, phantom.secretKey),
       ),
-    ).toBe(
-      "https://phantom.app/ul/browse/https%3A%2F%2Fdev.promanager.vip%2Fu%2Fbuy%3Fmobile%3D1%26x%3Da%20b?ref=https%3A%2F%2Fdev.promanager.vip",
+    ).toEqual({ transaction: "3xyz", session: "sess" });
+  });
+
+  it("reads an approval appended with a second ?", () => {
+    expect(
+      parsePhantomRedirect(
+        "https://app.example/pay?mobile=1?phantom_encryption_public_key=PK&nonce=N&data=D#top",
+      ),
+    ).toEqual({
+      phantomEncryptionPublicKey: "PK",
+      nonce: "N",
+      data: "D",
+      errorCode: undefined,
+      errorMessage: undefined,
+    });
+  });
+
+  it("reads a rejection", () => {
+    expect(
+      parsePhantomRedirect("https://app.example/pay?errorCode=4001&errorMessage=User%20rejected"),
+    ).toMatchObject({ errorCode: "4001", errorMessage: "User rejected" });
+  });
+
+  it("ignores a URL with no answer on it", () => {
+    expect(parsePhantomRedirect("https://app.example/pay?mobile=1")).toBeUndefined();
+    expect(parsePhantomRedirect("https://app.example/pay")).toBeUndefined();
+  });
+
+  it("strips the answer and keeps the page's own query and hash", () => {
+    expect(
+      stripPhantomRedirect("https://app.example/pay?mobile=1?nonce=N&data=D&errorCode=1#h"),
+    ).toBe("https://app.example/pay?mobile=1#h");
+    expect(stripPhantomRedirect("https://app.example/pay?nonce=N&data=D")).toBe(
+      "https://app.example/pay",
     );
   });
 });

package/src/phantom/urls.ts

@@ -1,16 +1,131 @@
+import bs58 from "bs58";
+import { encryptPayload } from "./crypto";
+
 /** Phantom's universal-link host. `https://phantom.app/ul` still answers; Phantom asks new code to use this one. */
 export const phantomUniversalLinkBase = "https://phantom.com/ul";
 
+export type PhantomCluster = "mainnet-beta" | "testnet" | "devnet";
+
+/**
+ * Deeplink provider methods, all Solana-only. `signAndSendTransaction` is
+ * deprecated by Phantom in favour of `signTransaction` and a broadcast by the
+ * page, and is kept for wallets that still honour it.
+ */
+export type PhantomMethod =
+  | "connect"
+  | "disconnect"
+  | "signTransaction"
+  | "signAllTransactions"
+  | "signAndSendTransaction"
+  | "signMessage";
+
+const base = (override?: string) => (override ?? phantomUniversalLinkBase).replace(/\/+$/, "");
+
 /**
  * Opens `url` inside Phantom's in-app browser, where Phantom injects
- * `window.phantom.ethereum`. Phantom's deeplinks carry no EVM methods, so
- * this is how a phone's browser reaches its EVM wallet.
+ * `window.phantom.ethereum` and `window.phantom.solana`. Phantom's deeplinks
+ * carry no EVM methods, so this is how a phone's browser reaches its EVM wallet.
  */
 export function phantomBrowseUrl(
   url: string,
   ref: string,
   options: { base?: string } = {},
 ): string {
-  const base = (options.base ?? phantomUniversalLinkBase).replace(/\/+$/, "");
-  return `${base}/browse/${encodeURIComponent(url)}?ref=${encodeURIComponent(ref)}`;
+  return `${base(options.base)}/browse/${encodeURIComponent(url)}?ref=${encodeURIComponent(ref)}`;
+}
+
+export interface PhantomConnectUrlParams {
+  appUrl: string;
+  dappEncryptionPublicKey: Uint8Array;
+  redirectLink: string;
+  cluster?: PhantomCluster;
+  base?: string;
+}
+
+export function phantomConnectUrl(params: PhantomConnectUrlParams): string {
+  const query = new URLSearchParams({
+    app_url: params.appUrl,
+    dapp_encryption_public_key: bs58.encode(params.dappEncryptionPublicKey),
+    redirect_link: params.redirectLink,
+  });
+  if (params.cluster) query.set("cluster", params.cluster);
+  return `${base(params.base)}/v1/connect?${query}`;
+}
+
+export interface PhantomMethodUrlParams {
+  method: Exclude<PhantomMethod, "connect">;
+  /** The fields the method's payload carries besides `session`. */
+  payload: Record<string, unknown>;
+  session: string;
+  dappEncryptionPublicKey: Uint8Array;
+  sharedSecret: Uint8Array;
+  redirectLink: string;
+  nonce?: Uint8Array;
+  base?: string;
+}
+
+/** A provider-method link: the payload, session included, sealed with the session's shared secret. */
+export function phantomMethodUrl(params: PhantomMethodUrlParams): string {
+  const sealed = encryptPayload(
+    { ...params.payload, session: params.session },
+    params.sharedSecret,
+    params.nonce,
+  );
+  const query = new URLSearchParams({
+    dapp_encryption_public_key: bs58.encode(params.dappEncryptionPublicKey),
+    nonce: sealed.nonce,
+    redirect_link: params.redirectLink,
+    payload: sealed.payload,
+  });
+  return `${base(params.base)}/v1/${params.method}?${query}`;
+}
+
+/** What Phantom appends to `redirect_link`. */
+export interface PhantomRedirectParams {
+  phantomEncryptionPublicKey?: string;
+  nonce?: string;
+  data?: string;
+  errorCode?: string;
+  errorMessage?: string;
+}
+
+const responseKeys = [
+  "phantom_encryption_public_key",
+  "nonce",
+  "data",
+  "errorCode",
+  "errorMessage",
+] as const;
+
+/**
+ * Reads Phantom's response off the return URL. Phantom appends with `?` even
+ * when the redirect link already has a query, so every `?` after the first is
+ * read as `&`. Returns undefined when the URL carries no response.
+ */
+export function parsePhantomRedirect(href: string): PhantomRedirectParams | undefined {
+  const [beforeHash] = href.split("#");
+  const at = beforeHash.indexOf("?");
+  if (at < 0) return undefined;
+  const query = new URLSearchParams(beforeHash.slice(at + 1).replace(/\?/g, "&"));
+  if (!query.has("errorCode") && !(query.has("data") && query.has("nonce"))) return undefined;
+  return {
+    phantomEncryptionPublicKey: query.get("phantom_encryption_public_key") ?? undefined,
+    nonce: query.get("nonce") ?? undefined,
+    data: query.get("data") ?? undefined,
+    errorCode: query.get("errorCode") ?? undefined,
+    errorMessage: query.get("errorMessage") ?? undefined,
+  };
+}
+
+/** `href` without Phantom's response parameters, for `history.replaceState` after handling it. */
+export function stripPhantomRedirect(href: string): string {
+  const hashAt = href.indexOf("#");
+  const hash = hashAt >= 0 ? href.slice(hashAt) : "";
+  const beforeHash = hashAt >= 0 ? href.slice(0, hashAt) : href;
+  const at = beforeHash.indexOf("?");
+  if (at < 0) return href;
+  const query = new URLSearchParams(beforeHash.slice(at + 1).replace(/\?/g, "&"));
+  for (const key of responseKeys) query.delete(key);
+  const rest = query.toString();
+  return `${beforeHash.slice(0, at)}${rest ? `?${rest}` : ""}${hash}`;
 }

package/types/phantom/crypto.d.ts

@@ -0,0 +1,27 @@
+/** 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 declare class PhantomDecryptError extends Error {
+    constructor(message?: string);
+}
+/** A fresh dapp keypair. Phantom recommends one per `connect`. */
+export declare function generateBoxKeyPair(): BoxKeyPair;
+export declare function boxKeyPairFromSecretKey(secretKey: Uint8Array): BoxKeyPair;
+/**
+ * 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 declare function sharedSecret(theirPublicKey: Uint8Array, mySecretKey: Uint8Array): Uint8Array;
+/** tweetnacl's `box.after`: XSalsa20-Poly1305 under the shared secret. */
+export declare function encryptPayload(value: unknown, secret: Uint8Array, nonce?: Uint8Array): EncryptedPayload;
+/** tweetnacl's `box.open.after`, then JSON. Throws PhantomDecryptError on a bad tag. */
+export declare function decryptPayload<T = unknown>(data: string, nonce: string, secret: Uint8Array): T;
+//# sourceMappingURL=crypto.d.ts.map

package/types/phantom/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/phantom/crypto.ts"],"names":[],"mappings":"AAIA,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,EAAE,UAAU,CAAC;CACvB;AAED,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,SAAiE;CAIrF;AAQD,kEAAkE;AAClE,wBAAgB,kBAAkB,IAAI,UAAU,CAG/C;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,CAEzE;AAkBD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,GAAG,UAAU,CAK5F;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,UAAU,EAClB,KAAK,GAAE,UAA4B,GAClC,gBAAgB,CAIlB;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,CAAC,CAQ9F"}

package/types/phantom/index.d.ts

@@ -1,3 +1,5 @@
+export { boxKeyPairFromSecretKey, decryptPayload, encryptPayload, generateBoxKeyPair, PhantomDecryptError, sharedSecret, type BoxKeyPair, type EncryptedPayload, } from "./crypto";
 export { connectPhantomEvm, discoverPhantomEthereumProvider, openInPhantom, phantomEthereumProvider, phantomEvmRoute, PhantomNotInjectedError, type ConnectPhantomEvmOptions, 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";
 //# sourceMappingURL=index.d.ts.map

package/types/phantom/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/phantom/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,aAAa,EACb,uBAAuB,EACvB,eAAe,EACf,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,GAC7B,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/phantom/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,EACZ,KAAK,UAAU,EACf,KAAK,gBAAgB,GACtB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,aAAa,EACb,uBAAuB,EACvB,eAAe,EACf,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,GAC7B,MAAM,OAAO,CAAC;AACf,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,cAAc,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,GAC3B,MAAM,QAAQ,CAAC"}