@multiplatform.one/web3 7.33.1 → 7.34.0

package/dist/cjs/phantom/solana.cjs

@@ -0,0 +1,309 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var solana_exports = {};
+__export(solana_exports, {
+  PhantomNotConnectedError: () => PhantomNotConnectedError,
+  phantomDeeplink: () => phantomDeeplink,
+  sendSolanaTransaction: () => sendSolanaTransaction
+});
+module.exports = __toCommonJS(solana_exports);
+var import_bs58 = __toESM(require("bs58"));
+var import_crypto = require("./crypto.cjs");
+var import_urls = require("./urls.cjs");
+class PhantomNotConnectedError extends Error {
+  constructor() {
+    super("no Phantom deeplink session: call connect() first");
+    this.name = "PhantomNotConnectedError";
+  }
+}
+const defaultStorageKey = "mpo.web3.phantom.deeplink";
+function defaultStorage() {
+  const storage = globalThis.localStorage;
+  if (!storage) throw new Error("phantomDeeplink: no localStorage here; pass `storage`");
+  return storage;
+}
+function currentHref() {
+  const href = globalThis.location?.href;
+  if (!href) throw new Error("phantomDeeplink: no location here; pass `redirectLink`");
+  return href;
+}
+function phantomDeeplink(config) {
+  const storageKey = config.storageKey ?? defaultStorageKey;
+  const storage = () => config.storage ?? defaultStorage();
+  const now = config.now ?? Date.now;
+  const navigate = config.navigate ?? (url => globalThis.location.assign(url));
+  const redirectLink = () => config.redirectLink ?? (0, import_urls.stripPhantomRedirect)(currentHref());
+  const load = () => {
+    const raw = storage().getItem(storageKey);
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  };
+  const save = record => storage().setItem(storageKey, JSON.stringify(record));
+  const connected = () => {
+    const record = load();
+    if (!record?.session || !record.phantomEncryptionPublicKey) throw new PhantomNotConnectedError();
+    return record;
+  };
+  const methodUrl = (record, method, payload) => {
+    const keyPair = (0, import_crypto.boxKeyPairFromSecretKey)(import_bs58.default.decode(record.dappSecretKey));
+    return (0, import_urls.phantomMethodUrl)({
+      method,
+      payload,
+      session: record.session,
+      dappEncryptionPublicKey: keyPair.publicKey,
+      sharedSecret: (0, import_crypto.sharedSecret)(import_bs58.default.decode(record.phantomEncryptionPublicKey), keyPair.secretKey),
+      redirectLink: redirectLink(),
+      base: config.base
+    });
+  };
+  const request = (method, payload) => {
+    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 = (0, import_crypto.generateBoxKeyPair)();
+      const url = (0, import_urls.phantomConnectUrl)({
+        appUrl: config.appUrl,
+        dappEncryptionPublicKey: keyPair.publicKey,
+        redirectLink: redirectLink(),
+        cluster: config.cluster,
+        base: config.base
+      });
+      save({
+        dappSecretKey: import_bs58.default.encode(keyPair.secretKey),
+        cluster: config.cluster,
+        pending: {
+          method: "connect",
+          at: now()
+        }
+      });
+      navigate(url);
+      return url;
+    },
+    signTransaction(serializedTransaction) {
+      return request("signTransaction", {
+        transaction: import_bs58.default.encode(serializedTransaction)
+      });
+    },
+    signAllTransactions(serializedTransactions) {
+      return request("signAllTransactions", {
+        transactions: serializedTransactions.map(tx => import_bs58.default.encode(tx))
+      });
+    },
+    signAndSendTransaction(serializedTransaction, sendOptions) {
+      return request("signAndSendTransaction", {
+        transaction: import_bs58.default.encode(serializedTransaction),
+        ...(sendOptions ? {
+          sendOptions
+        } : {})
+      });
+    },
+    signMessage(message, display) {
+      const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+      return request("signMessage", {
+        message: import_bs58.default.encode(bytes),
+        ...(display ? {
+          display
+        } : {})
+      });
+    },
+    disconnect() {
+      const url = methodUrl(connected(), "disconnect", {});
+      storage().removeItem(storageKey);
+      navigate(url);
+      return url;
+    },
+    handleRedirect(href) {
+      const params = (0, import_urls.parsePhantomRedirect)(href ?? currentHref());
+      if (!params) return void 0;
+      const record = load();
+      const method = record?.pending?.method;
+      if (params.errorCode) {
+        if (record) save({
+          ...record,
+          pending: void 0
+        });
+        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 = import_bs58.default.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 = (0, import_crypto.decryptPayload)(params.data, params.nonce, (0, import_crypto.sharedSecret)(import_bs58.default.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: void 0
+            });
+            return {
+              ok: true,
+              method,
+              publicKey,
+              session
+            };
+          }
+        case "signTransaction":
+          save({
+            ...record,
+            pending: void 0
+          });
+          return {
+            ok: true,
+            method,
+            transaction: import_bs58.default.decode(String(data.transaction))
+          };
+        case "signAllTransactions":
+          save({
+            ...record,
+            pending: void 0
+          });
+          return {
+            ok: true,
+            method,
+            transactions: data.transactions.map(tx => import_bs58.default.decode(tx))
+          };
+        case "signAndSendTransaction":
+          save({
+            ...record,
+            pending: void 0
+          });
+          return {
+            ok: true,
+            method,
+            signature: String(data.signature)
+          };
+        case "signMessage":
+          save({
+            ...record,
+            pending: void 0
+          });
+          return {
+            ok: true,
+            method,
+            signature: import_bs58.default.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) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+async function sendSolanaTransaction(rpcUrl, signedTransaction, options = {}) {
+  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();
+  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;
+}