@swype-org/deposit 0.3.13 → 0.3.15

package/dist/index.cjs

@@ -90,6 +90,414 @@ function parseCloseRequest(data) {
   }
   return { type: "blink:close-request" };
 }
+function parseIframeReady(data) {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const msg = data;
+  if (msg.type !== "blink:iframe-ready") {
+    return null;
+  }
+  return { type: "blink:iframe-ready" };
+}
+function buildSignedPayloadMessage(merchantId, payload, signature) {
+  return {
+    type: "blink:signed-payload",
+    merchantId,
+    payload,
+    signature
+  };
+}
+
+// src/walletBridge/discover.ts
+function createWalletDiscoverer() {
+  if (typeof window === "undefined") {
+    return makeNoopHandle();
+  }
+  const registry = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let destroyed = false;
+  const onAnnounce = (event) => {
+    if (destroyed) return;
+    const detail = event.detail;
+    if (!isValidProviderDetail(detail)) {
+      console.info("[blink-bridge:parent] dropping malformed EIP-6963 announcement", {
+        rawInfo: event.detail && event.detail.info
+      });
+      return;
+    }
+    const existing = registry.get(detail.info.uuid);
+    if (existing && existing.provider === detail.provider) {
+      return;
+    }
+    console.info("[blink-bridge:parent] EIP-6963 announceProvider", {
+      rdns: detail.info.rdns,
+      name: detail.info.name,
+      uuid: detail.info.uuid
+    });
+    registry.set(detail.info.uuid, {
+      info: { ...detail.info },
+      provider: detail.provider
+    });
+    notify();
+  };
+  window.addEventListener("eip6963:announceProvider", onAnnounce);
+  requestProviders();
+  const RESWEEP_INTERVALS_MS = [500, 1500, 3e3, 6e3];
+  const reSweepTimers = [];
+  for (const ms of RESWEEP_INTERVALS_MS) {
+    reSweepTimers.push(
+      setTimeout(() => {
+        if (!destroyed) requestProviders();
+      }, ms)
+    );
+  }
+  function requestProviders() {
+    try {
+      window.dispatchEvent(new Event("eip6963:requestProvider"));
+    } catch {
+    }
+  }
+  function notify() {
+    const snapshot = list();
+    for (const listener of listeners) {
+      try {
+        listener(snapshot);
+      } catch {
+      }
+    }
+  }
+  function list() {
+    return [...registry.values()];
+  }
+  return {
+    list,
+    get(uuid) {
+      return registry.get(uuid)?.provider;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    requestProviders,
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      window.removeEventListener("eip6963:announceProvider", onAnnounce);
+      for (const t of reSweepTimers) clearTimeout(t);
+      registry.clear();
+      listeners.clear();
+    }
+  };
+}
+function makeNoopHandle() {
+  return {
+    list: () => [],
+    get: () => void 0,
+    subscribe: () => () => {
+    },
+    requestProviders: () => {
+    },
+    destroy: () => {
+    }
+  };
+}
+function isValidProviderDetail(value) {
+  if (!value || typeof value !== "object") return false;
+  const detail = value;
+  const info = detail.info;
+  const provider = detail.provider;
+  if (!info || !provider) return false;
+  if (typeof info.uuid !== "string" || info.uuid.length === 0) return false;
+  if (typeof info.name !== "string") return false;
+  if (typeof info.rdns !== "string") return false;
+  if (typeof provider.request !== "function") return false;
+  return true;
+}
+
+// src/walletBridge/protocol.ts
+var BRIDGE_PROTOCOL_VERSION = 1;
+var ALLOWED_RPC_METHODS = /* @__PURE__ */ new Set([
+  // Read
+  "eth_accounts",
+  "eth_blockNumber",
+  "eth_call",
+  "eth_chainId",
+  "eth_estimateGas",
+  "eth_gasPrice",
+  "eth_getBalance",
+  "eth_getCode",
+  "eth_getStorageAt",
+  "eth_getTransactionByHash",
+  "eth_getTransactionCount",
+  "eth_getTransactionReceipt",
+  "net_version",
+  "wallet_getCapabilities",
+  "wallet_getCallsStatus",
+  // Write / sign
+  "eth_requestAccounts",
+  "eth_sendTransaction",
+  "eth_sendRawTransaction",
+  "eth_sign",
+  "personal_sign",
+  "eth_signTypedData",
+  "eth_signTypedData_v3",
+  "eth_signTypedData_v4",
+  "wallet_addEthereumChain",
+  "wallet_switchEthereumChain",
+  "wallet_sendCalls",
+  "wallet_watchAsset"
+]);
+var FORWARDED_PROVIDER_EVENTS = [
+  "accountsChanged",
+  "chainChanged",
+  "connect",
+  "disconnect",
+  "message"
+];
+function parseBridgeMessage(data) {
+  if (!data || typeof data !== "object") return null;
+  const msg = data;
+  if (msg.protocolVersion !== BRIDGE_PROTOCOL_VERSION) return null;
+  switch (msg.type) {
+    case "blink:bridge-hello":
+      return msg;
+    case "blink:wallets-advertised":
+      return Array.isArray(msg.wallets) ? msg : null;
+    case "blink:rpc-request":
+      if (typeof msg.uuid !== "string" || typeof msg.id !== "string" || typeof msg.method !== "string") {
+        return null;
+      }
+      return msg;
+    case "blink:rpc-response":
+      if (typeof msg.id !== "string") return null;
+      return msg;
+    case "blink:rpc-event":
+      if (typeof msg.uuid !== "string" || typeof msg.event !== "string" || !Array.isArray(msg.args)) {
+        return null;
+      }
+      return msg;
+    case "blink:resolve-by-flag":
+      if (typeof msg.id !== "string" || !Array.isArray(msg.flags)) return null;
+      if (!msg.flags.every((f) => typeof f === "string" && f.length > 0)) return null;
+      return msg;
+    case "blink:resolve-by-flag-response":
+      if (typeof msg.id !== "string") return null;
+      if (msg.match !== null && (typeof msg.match !== "object" || !msg.match)) return null;
+      return msg;
+    default:
+      return null;
+  }
+}
+
+// src/walletBridge/rpcHost.ts
+function attachRpcHost(options) {
+  const { iframeWindow, iframeOrigin, discoverer } = options;
+  const log = options.log ?? noopLog;
+  if (typeof window === "undefined") {
+    return { detach: () => {
+    } };
+  }
+  let detached = false;
+  const subscriptions = /* @__PURE__ */ new Map();
+  const unsubscribeFromDiscoverer = discoverer.subscribe((snapshot) => {
+    if (detached) return;
+    advertiseWallets(snapshot);
+  });
+  function postToIframe(message) {
+    if (detached) return;
+    try {
+      iframeWindow.postMessage(message, iframeOrigin);
+    } catch (err) {
+      log("postMessage to iframe failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  function advertiseWallets(snapshot) {
+    const wallets = snapshot.map((entry) => ({
+      uuid: entry.info.uuid,
+      rdns: entry.info.rdns,
+      name: entry.info.name,
+      icon: entry.info.icon
+    }));
+    console.info("[blink-bridge:parent] advertising wallets", wallets.map((w) => ({
+      rdns: w.rdns,
+      name: w.name
+    })));
+    const message = {
+      type: "blink:wallets-advertised",
+      protocolVersion: BRIDGE_PROTOCOL_VERSION,
+      wallets
+    };
+    postToIframe(message);
+  }
+  function ensureSubscription(uuid, provider) {
+    if (subscriptions.has(uuid)) return;
+    if (typeof provider.on !== "function") {
+      subscriptions.set(uuid, { provider, listeners: /* @__PURE__ */ new Map() });
+      return;
+    }
+    const record = { provider, listeners: /* @__PURE__ */ new Map() };
+    for (const event of FORWARDED_PROVIDER_EVENTS) {
+      const listener = (...args) => {
+        const eventMessage = {
+          type: "blink:rpc-event",
+          protocolVersion: BRIDGE_PROTOCOL_VERSION,
+          uuid,
+          event,
+          args
+        };
+        postToIframe(eventMessage);
+      };
+      try {
+        provider.on(event, listener);
+        record.listeners.set(event, listener);
+      } catch (err) {
+        log(`provider.on('${event}') threw \u2014 skipping that event`, {
+          uuid,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    subscriptions.set(uuid, record);
+  }
+  function unsubscribeAll() {
+    for (const [, record] of subscriptions) {
+      const provider = record.provider;
+      if (typeof provider.removeListener !== "function") continue;
+      for (const [event, listener] of record.listeners) {
+        try {
+          provider.removeListener(event, listener);
+        } catch {
+        }
+      }
+    }
+    subscriptions.clear();
+  }
+  function sendError(id, code, message, data) {
+    const response = {
+      type: "blink:rpc-response",
+      protocolVersion: BRIDGE_PROTOCOL_VERSION,
+      id,
+      error: data === void 0 ? { code, message } : { code, message, data }
+    };
+    postToIframe(response);
+  }
+  function sendResult(id, result) {
+    const response = {
+      type: "blink:rpc-response",
+      protocolVersion: BRIDGE_PROTOCOL_VERSION,
+      id,
+      result
+    };
+    postToIframe(response);
+  }
+  const onMessage = (event) => {
+    if (detached) return;
+    if (event.source !== iframeWindow) return;
+    if (event.origin !== iframeOrigin) return;
+    const message = parseBridgeMessage(event.data);
+    if (!message) return;
+    switch (message.type) {
+      case "blink:bridge-hello": {
+        advertiseWallets(discoverer.list());
+        discoverer.requestProviders();
+        return;
+      }
+      case "blink:rpc-request": {
+        const { id, uuid, method, params } = message;
+        console.info("[blink-bridge:parent] rpc-request", { uuid, method });
+        if (!ALLOWED_RPC_METHODS.has(method)) {
+          log("rejecting non-allowlisted method", { uuid, method });
+          sendError(id, -32601, `Method not allowed: ${method}`);
+          return;
+        }
+        const provider = discoverer.get(uuid);
+        if (!provider) {
+          log("no provider for uuid", { uuid, method });
+          sendError(id, -32602, `Unknown wallet: ${uuid}`);
+          return;
+        }
+        ensureSubscription(uuid, provider);
+        provider.request({ method, params }).then((result) => {
+          console.info("[blink-bridge:parent] rpc-result", { uuid, method, ok: true });
+          sendResult(id, result);
+        }).catch((err) => {
+          const { code, message: errMessage, data } = normalizeProviderError(err);
+          console.info("[blink-bridge:parent] rpc-error", { uuid, method, code, message: errMessage });
+          sendError(id, code, errMessage, data);
+        });
+        return;
+      }
+      case "blink:resolve-by-flag": {
+        const match = resolveByFlag(discoverer.list(), message.flags, log);
+        console.info("[blink-bridge:parent] resolveByFlag", {
+          flags: message.flags,
+          match: match ? { rdns: match.rdns, flag: match.flag } : null
+        });
+        const response = {
+          type: "blink:resolve-by-flag-response",
+          protocolVersion: BRIDGE_PROTOCOL_VERSION,
+          id: message.id,
+          match
+        };
+        postToIframe(response);
+        return;
+      }
+      case "blink:wallets-advertised":
+      case "blink:rpc-response":
+      case "blink:rpc-event":
+      case "blink:resolve-by-flag-response":
+        return;
+    }
+  };
+  window.addEventListener("message", onMessage);
+  return {
+    detach() {
+      if (detached) return;
+      detached = true;
+      window.removeEventListener("message", onMessage);
+      unsubscribeFromDiscoverer();
+      unsubscribeAll();
+    }
+  };
+}
+function noopLog() {
+}
+function resolveByFlag(snapshot, flags, log) {
+  for (const flag of flags) {
+    for (const entry of snapshot) {
+      let value;
+      try {
+        value = entry.provider[flag];
+      } catch (err) {
+        log("provider threw on flag read \u2014 skipping", {
+          rdns: entry.info.rdns,
+          flag,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        continue;
+      }
+      if (value) {
+        return { rdns: entry.info.rdns, uuid: entry.info.uuid, flag };
+      }
+    }
+  }
+  return null;
+}
+function normalizeProviderError(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    const code = typeof e.code === "number" ? e.code : -32603;
+    const message = typeof e.message === "string" ? e.message : err instanceof Error ? err.message : "Provider error";
+    const data = "data" in e ? e.data : void 0;
+    return data === void 0 ? { code, message } : { code, message, data };
+  }
+  return { code: -32603, message: typeof err === "string" ? err : "Provider error" };
+}
 
 // src/iframe.ts
 var STYLE_ID = "blink-deposit-styles";
@@ -126,13 +534,26 @@ function createIframe(url, containerElement) {
   const iframe = document.createElement("iframe");
   iframe.src = url;
   const iframeOrigin = new URL(url).origin;
-  iframe.allow = `publickey-credentials-get ${iframeOrigin}; publickey-credentials-create ${iframeOrigin}`;
+  iframe.allow = `publickey-credentials-get ${iframeOrigin}; publickey-credentials-create ${iframeOrigin}; clipboard-write ${iframeOrigin}`;
   const handle = document.createElement("div");
   container.appendChild(handle);
   container.appendChild(iframe);
   overlay.appendChild(container);
   const mountTarget = containerElement ?? document.body;
   mountTarget.appendChild(overlay);
+  const discoverer = createWalletDiscoverer();
+  let rpcHostHandle = null;
+  const attachBridge = () => {
+    if (rpcHostHandle) return;
+    if (!iframe.contentWindow) return;
+    rpcHostHandle = attachRpcHost({
+      iframeWindow: iframe.contentWindow,
+      iframeOrigin,
+      discoverer
+    });
+  };
+  attachBridge();
+  iframe.addEventListener("load", attachBridge);
   const savedOverflow = document.body.style.overflow;
   document.body.style.overflow = "hidden";
   const onBackdropClick = (event) => {
@@ -159,6 +580,7 @@ function createIframe(url, containerElement) {
     if (closed) return;
     closed = true;
     removeListeners();
+    detachBridge();
     overlay.setAttribute("data-blink-closing", "");
     let removed = false;
     const removeOverlay = () => {
@@ -171,6 +593,14 @@ function createIframe(url, containerElement) {
     container.addEventListener("animationend", removeOverlay, { once: true });
     setTimeout(removeOverlay, CLOSE_DURATION_MS + 50);
   }
+  function detachBridge() {
+    iframe.removeEventListener("load", attachBridge);
+    if (rpcHostHandle) {
+      rpcHostHandle.detach();
+      rpcHostHandle = null;
+    }
+    discoverer.destroy();
+  }
   return {
     get contentWindow() {
       return iframe.contentWindow;
@@ -189,6 +619,7 @@ function createIframe(url, containerElement) {
       if (!closed) {
         closed = true;
         removeListeners();
+        detachBridge();
         overlay.remove();
         unlockScroll();
       }
@@ -311,8 +742,10 @@ function isValidTokenAddress(value) {
   return TOKEN_ADDRESS_RE.test(value) || SOLANA_ADDRESS_RE.test(value);
 }
 function validateDepositRequest(request) {
-  if (!Number.isFinite(request.amount) || request.amount <= 0) {
-    throw new DepositError("INVALID_REQUEST", "amount must be a positive number.");
+  if (request.amount !== null) {
+    if (typeof request.amount !== "number" || !Number.isFinite(request.amount) || request.amount <= 0) {
+      throw new DepositError("INVALID_REQUEST", "amount must be a positive number or null.");
+    }
   }
   if (!Number.isInteger(request.chainId) || request.chainId <= 0) {
     throw new DepositError("INVALID_REQUEST", "chainId must be a positive integer.");
@@ -503,30 +936,16 @@ var Deposit = class {
   async runSignerFlow(request, requestId, onComplete, onError) {
     try {
       const webviewBaseUrl = this.config.webviewBaseUrl ?? DEFAULT_WEBVIEW_BASE_URL;
+      this.hostedOrigin = this.config.hostedFlowOrigin ?? new URL(webviewBaseUrl).origin;
       this.log("Calling signer", {
         signer: typeof this.config.signer === "string" ? this.config.signer : "<function>"
       });
       const signerRequest = buildSignerRequest(request, webviewBaseUrl);
-      const signerResponse = await callSigner(
-        this.config.signer,
-        signerRequest,
-        this.config.signerTimeoutMs
-      );
-      this.lastSignerResponse = signerResponse;
-      this.log("Signer responded", { merchantId: signerResponse.merchantId });
-      if (this.requestId !== requestId) {
-        this.log("Request superseded after signer response");
-        return;
-      }
-      const hostedUrl = new URL(webviewBaseUrl);
-      hostedUrl.searchParams.set("merchantId", signerResponse.merchantId);
-      hostedUrl.searchParams.set("payload", signerResponse.payload);
-      hostedUrl.searchParams.set("signature", signerResponse.signature);
-      const targetUrl = hostedUrl.toString();
-      this.hostedOrigin = this.config.hostedFlowOrigin ?? hostedUrl.origin;
-      const iframeHandle = createIframe(targetUrl, this.config.containerElement);
-      this.iframe = iframeHandle;
-      iframeHandle.onClose(() => {
+      const preloadUrl = new URL(webviewBaseUrl);
+      preloadUrl.searchParams.set("preload", "true");
+      const preloadIframe = createIframe(preloadUrl.toString(), this.config.containerElement);
+      this.iframe = preloadIframe;
+      preloadIframe.onClose(() => {
         onError(
           new DepositError(
             "DEPOSIT_DISMISSED",
@@ -536,9 +955,60 @@ var Deposit = class {
         this.cleanup();
         this.emit("close");
       });
-      this.startMessageListener(iframeHandle, onComplete);
-      this.setStatus("iframe-active");
-      this.log("Iframe opened with hosted flow", { url: targetUrl });
+      const signerPromise = callSigner(
+        this.config.signer,
+        signerRequest,
+        this.config.signerTimeoutMs
+      );
+      const iframeReadyPromise = this.waitForIframeReady(preloadIframe);
+      const [signerResponse, iframeReady] = await Promise.all([
+        signerPromise,
+        iframeReadyPromise
+      ]);
+      this.lastSignerResponse = signerResponse;
+      this.log("Signer responded", { merchantId: signerResponse.merchantId });
+      if (this.requestId !== requestId || preloadIframe.isClosed()) {
+        this.log("Request superseded or iframe dismissed during signer call");
+        return;
+      }
+      if (iframeReady) {
+        const contentWindow = preloadIframe.contentWindow;
+        if (contentWindow) {
+          contentWindow.postMessage(
+            buildSignedPayloadMessage(
+              signerResponse.merchantId,
+              signerResponse.payload,
+              signerResponse.signature
+            ),
+            this.hostedOrigin
+          );
+        }
+        this.startMessageListener(preloadIframe, onComplete);
+        this.setStatus("iframe-active");
+        this.log("Payload delivered via postMessage (preload path)");
+      } else {
+        preloadIframe.destroy();
+        const hostedUrl = new URL(webviewBaseUrl);
+        hostedUrl.searchParams.set("merchantId", signerResponse.merchantId);
+        hostedUrl.searchParams.set("payload", signerResponse.payload);
+        hostedUrl.searchParams.set("signature", signerResponse.signature);
+        const targetUrl = hostedUrl.toString();
+        const iframeHandle = createIframe(targetUrl, this.config.containerElement);
+        this.iframe = iframeHandle;
+        iframeHandle.onClose(() => {
+          onError(
+            new DepositError(
+              "DEPOSIT_DISMISSED",
+              "The deposit was dismissed before the transfer completed."
+            )
+          );
+          this.cleanup();
+          this.emit("close");
+        });
+        this.startMessageListener(iframeHandle, onComplete);
+        this.setStatus("iframe-active");
+        this.log("Iframe opened with hosted flow (fallback path)", { url: targetUrl });
+      }
     } catch (err) {
       if (this.requestId !== requestId) return;
       this.log("Signer flow failed", { error: err instanceof Error ? err.message : String(err) });
@@ -554,6 +1024,25 @@ var Deposit = class {
       }
     }
   }
+  waitForIframeReady(iframeHandle) {
+    return new Promise((resolve) => {
+      const handler = (event) => {
+        if (event.origin !== this.hostedOrigin) return;
+        if (event.source !== iframeHandle.contentWindow) return;
+        if (parseIframeReady(event.data)) {
+          window.removeEventListener("message", handler);
+          clearTimeout(timeout);
+          resolve(true);
+        }
+      };
+      window.addEventListener("message", handler);
+      const timeout = setTimeout(() => {
+        window.removeEventListener("message", handler);
+        this.log("Iframe ready timeout \u2014 falling back to URL params");
+        resolve(false);
+      }, 2e3);
+    });
+  }
   startMessageListener(iframeHandle, onComplete) {
     const handler = (event) => {
       if (this.hostedOrigin && event.origin !== this.hostedOrigin) {
@@ -627,12 +1116,17 @@ var Checkout = Deposit;
 // src/index.ts
 var VERSION = "0.3.0";
 
+exports.ALLOWED_RPC_METHODS = ALLOWED_RPC_METHODS;
+exports.BRIDGE_PROTOCOL_VERSION = BRIDGE_PROTOCOL_VERSION;
 exports.Checkout = Checkout;
 exports.CheckoutError = CheckoutError;
 exports.DEFAULT_WEBVIEW_BASE_URL = DEFAULT_WEBVIEW_BASE_URL;
 exports.Deposit = Deposit;
 exports.DepositError = DepositError;
 exports.VERSION = VERSION;
+exports.attachRpcHost = attachRpcHost;
+exports.createWalletDiscoverer = createWalletDiscoverer;
 exports.getDisplayMessage = getDisplayMessage;
+exports.parseBridgeMessage = parseBridgeMessage;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map