@swype-org/deposit 0.3.0

package/dist/chunk-RG2MWY2W.js

@@ -0,0 +1,583 @@
+// src/errors.ts
+var DepositError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "DepositError";
+    this.code = code;
+  }
+};
+var CheckoutError2 = DepositError;
+var DISPLAY_MESSAGES = {
+  DEPOSIT_DISMISSED: "The deposit was dismissed before the transfer completed.",
+  CHECKOUT_DISMISSED: "The checkout was dismissed before the transfer completed.",
+  SIGNER_REQUEST_FAILED: "Unable to start the payment. Please try again.",
+  SIGNER_NETWORK_ERROR: "Unable to reach the payment server. Check your connection and try again.",
+  SIGNER_RESPONSE_INVALID: "The payment server returned an unexpected response.",
+  SIGNER_TIMEOUT: "The payment server took too long to respond. Please try again.",
+  FLOW_TIMEOUT: "The payment flow timed out. Please try again.",
+  INVALID_REQUEST: "Invalid payment request. Please check your input."
+};
+function getDisplayMessage(error) {
+  return DISPLAY_MESSAGES[error.code] ?? error.message;
+}
+
+// src/messages.ts
+function parseTransferComplete(data) {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const msg = data;
+  if (msg.type !== "blink:transfer-complete") {
+    return null;
+  }
+  const transfer = msg.transfer;
+  if (!transfer || typeof transfer !== "object") {
+    return null;
+  }
+  const t = transfer;
+  if (typeof t.id !== "string" || typeof t.status !== "string") {
+    return null;
+  }
+  return {
+    type: "blink:transfer-complete",
+    transfer: {
+      id: t.id,
+      status: t.status,
+      amount: parseAmount(t.amount),
+      destinations: parseDestinations(t.destinations)
+    }
+  };
+}
+function parseAmount(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const a = value;
+  return {
+    amount: Number(a.amount ?? 0),
+    currency: String(a.currency ?? "")
+  };
+}
+function parseDestinations(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.filter((entry) => !!entry && typeof entry === "object").map((entry) => ({
+    chainId: String(entry.chainId ?? ""),
+    address: String(entry.address ?? ""),
+    token: entry.token && typeof entry.token === "object" ? {
+      address: String(entry.token.address ?? ""),
+      symbol: String(entry.token.symbol ?? "")
+    } : void 0
+  }));
+}
+function buildAckMessage(transferId) {
+  return {
+    type: "blink:transfer-complete-ack",
+    transferId
+  };
+}
+function parseCloseRequest(data) {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const msg = data;
+  if (msg.type !== "blink:close-request") {
+    return null;
+  }
+  return { type: "blink:close-request" };
+}
+
+// src/iframe.ts
+var STYLE_ID = "blink-deposit-styles";
+var CLOSE_DURATION_MS = 280;
+var STYLES = `
+@keyframes blink-fade-in{from{opacity:0}to{opacity:1}}
+@keyframes blink-fade-out{from{opacity:1}to{opacity:0}}
+@keyframes blink-slide-up{from{opacity:0;transform:translateY(20px)}to{opacity:1;transform:translateY(0)}}
+@keyframes blink-slide-up-full{from{transform:translateY(100%)}to{transform:translateY(0)}}
+@keyframes blink-slide-down-full{from{transform:translateY(0)}to{transform:translateY(100%)}}
+[data-blink-overlay]{position:fixed;inset:0;background:rgba(0,0,0,.6);display:flex;align-items:center;justify-content:center;z-index:2147483647;animation:blink-fade-in .2s ease-out;backdrop-filter:blur(4px);-webkit-backdrop-filter:blur(4px)}
+[data-blink-overlay][data-blink-closing]{animation:blink-fade-out ${CLOSE_DURATION_MS}ms ease-in forwards;pointer-events:none}
+[data-blink-container]{width:min(440px,90vw);height:min(600px,85vh);border-radius:20px;overflow:hidden;box-shadow:0 24px 80px rgba(0,0,0,.4);animation:blink-slide-up .25s ease-out;display:flex;flex-direction:column;background:#f9fdff}
+[data-blink-overlay][data-blink-closing] [data-blink-container]{opacity:0;transition:opacity ${CLOSE_DURATION_MS}ms ease-in}
+[data-blink-handle]{display:none;justify-content:center;padding:10px 0 2px;background:#f9fdff;flex-shrink:0}
+[data-blink-handle]::after{content:'';width:36px;height:4px;border-radius:2px;background:#d1d5db}
+[data-blink-container] iframe{width:100%;flex:1;border:none;display:block;background:#f9fdff}
+@media(max-width:480px){[data-blink-overlay]{align-items:flex-end;touch-action:none;overscroll-behavior:contain}[data-blink-container]{width:100%;max-width:100%;height:66vh;border-radius:20px 20px 0 0;box-shadow:0 -8px 40px rgba(0,0,0,.25);animation:blink-slide-up-full .35s cubic-bezier(.32,.72,0,1);padding-bottom:env(safe-area-inset-bottom,0px)}[data-blink-overlay][data-blink-closing] [data-blink-container]{opacity:1;animation:blink-slide-down-full ${CLOSE_DURATION_MS}ms ease-in forwards}[data-blink-handle]{display:flex}}
+`;
+function createIframe(url, containerElement) {
+  ensureStyles();
+  let closed = false;
+  let closeCallback = null;
+  const overlay = document.createElement("div");
+  overlay.setAttribute("data-blink-overlay", "");
+  const container = document.createElement("div");
+  container.setAttribute("data-blink-container", "");
+  const iframe = document.createElement("iframe");
+  iframe.src = url;
+  const iframeOrigin = new URL(url).origin;
+  iframe.allow = `publickey-credentials-get ${iframeOrigin}; publickey-credentials-create ${iframeOrigin}`;
+  const handle = document.createElement("div");
+  handle.setAttribute("data-blink-handle", "");
+  container.appendChild(handle);
+  container.appendChild(iframe);
+  overlay.appendChild(container);
+  const mountTarget = containerElement ?? document.body;
+  mountTarget.appendChild(overlay);
+  const savedOverflow = document.body.style.overflow;
+  document.body.style.overflow = "hidden";
+  const onBackdropClick = (event) => {
+    if (event.target === overlay) triggerClose();
+  };
+  const onKeyDown = (event) => {
+    if (event.key === "Escape") triggerClose();
+  };
+  const onTouchMove = (event) => {
+    if (event.target === overlay) event.preventDefault();
+  };
+  overlay.addEventListener("click", onBackdropClick);
+  overlay.addEventListener("touchmove", onTouchMove, { passive: false });
+  document.addEventListener("keydown", onKeyDown);
+  function removeListeners() {
+    overlay.removeEventListener("click", onBackdropClick);
+    overlay.removeEventListener("touchmove", onTouchMove);
+    document.removeEventListener("keydown", onKeyDown);
+  }
+  function unlockScroll() {
+    document.body.style.overflow = savedOverflow;
+  }
+  function triggerClose() {
+    if (closed) return;
+    closed = true;
+    removeListeners();
+    overlay.setAttribute("data-blink-closing", "");
+    let removed = false;
+    const removeOverlay = () => {
+      if (removed) return;
+      removed = true;
+      overlay.remove();
+      unlockScroll();
+      closeCallback?.();
+    };
+    container.addEventListener("animationend", removeOverlay, { once: true });
+    setTimeout(removeOverlay, CLOSE_DURATION_MS + 50);
+  }
+  return {
+    get contentWindow() {
+      return iframe.contentWindow;
+    },
+    close() {
+      triggerClose();
+    },
+    isClosed() {
+      return closed;
+    },
+    onClose(callback) {
+      closeCallback = callback;
+    },
+    destroy() {
+      closeCallback = null;
+      if (!closed) {
+        closed = true;
+        removeListeners();
+        overlay.remove();
+        unlockScroll();
+      }
+    }
+  };
+}
+function ensureStyles() {
+  if (document.getElementById(STYLE_ID)) return;
+  const style = document.createElement("style");
+  style.id = STYLE_ID;
+  style.textContent = STYLES;
+  document.head.appendChild(style);
+}
+
+// src/signer.ts
+var DEFAULT_SIGNER_TIMEOUT_MS = 15e3;
+async function callSigner(signer, request, timeoutMs) {
+  const timeout = timeoutMs ?? DEFAULT_SIGNER_TIMEOUT_MS;
+  const body = typeof signer === "function" ? await invokeSignerFunction(signer, request, timeout) : await invokeSignerUrl(signer, request, timeout);
+  validateSignerResponse(body);
+  return body;
+}
+async function invokeSignerUrl(signerUrl, request, timeoutMs) {
+  let response;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    response = await fetch(signerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request),
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (controller.signal.aborted) {
+      throw new CheckoutError(
+        "SIGNER_TIMEOUT",
+        `Signer did not respond within ${timeoutMs}ms.`
+      );
+    }
+    throw new CheckoutError(
+      "SIGNER_NETWORK_ERROR",
+      "Unable to reach the merchant signer. Check the signer URL and network connectivity."
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    const detail = body?.error ?? `Signer returned HTTP ${response.status}.`;
+    throw new CheckoutError("SIGNER_REQUEST_FAILED", detail);
+  }
+  return body;
+}
+async function invokeSignerFunction(signer, request, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new CheckoutError("SIGNER_TIMEOUT", `Signer did not respond within ${timeoutMs}ms.`)),
+      timeoutMs
+    );
+    signer(request).then(
+      (result) => {
+        clearTimeout(timer);
+        resolve(result);
+      },
+      (err) => {
+        clearTimeout(timer);
+        if (err instanceof DepositError) {
+          reject(err);
+        } else {
+          reject(new CheckoutError(
+            "SIGNER_REQUEST_FAILED",
+            err instanceof Error ? err.message : "Signer function threw an error."
+          ));
+        }
+      }
+    );
+  });
+}
+function validateSignerResponse(body) {
+  const obj = body;
+  if (!obj || typeof obj.merchantId !== "string" || typeof obj.payload !== "string" || typeof obj.signature !== "string" || !obj.preview || typeof obj.preview !== "object") {
+    throw new CheckoutError(
+      "SIGNER_RESPONSE_INVALID",
+      "Signer response is missing required fields (merchantId, payload, signature, preview)."
+    );
+  }
+}
+
+// src/validation.ts
+var EVM_ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
+var TOKEN_ADDRESS_RE = /^0x[a-fA-F0-9]{1,40}$/;
+function validateDepositRequest(request) {
+  if (!Number.isFinite(request.amount) || request.amount <= 0) {
+    throw new DepositError("INVALID_REQUEST", "amount must be a positive number.");
+  }
+  if (!Number.isInteger(request.chainId) || request.chainId <= 0) {
+    throw new DepositError("INVALID_REQUEST", "chainId must be a positive integer.");
+  }
+  if (!EVM_ADDRESS_RE.test(request.address)) {
+    throw new DepositError(
+      "INVALID_REQUEST",
+      "address must be a 0x-prefixed, 40-character hex string."
+    );
+  }
+  if (typeof request.token !== "string" || !TOKEN_ADDRESS_RE.test(request.token)) {
+    throw new DepositError("INVALID_REQUEST", "token must be a 0x-prefixed hex address.");
+  }
+}
+function buildSignerRequest(request, webviewBaseUrl) {
+  const base = {
+    amount: request.amount,
+    chainId: request.chainId,
+    address: request.address,
+    token: request.token,
+    callbackScheme: request.callbackScheme ?? null,
+    url: webviewBaseUrl,
+    version: "v1"
+  };
+  if (request.reference) base.reference = request.reference;
+  if (request.metadata && Object.keys(request.metadata).length > 0) {
+    base.metadata = request.metadata;
+  }
+  return base;
+}
+
+// src/checkout.ts
+var DEFAULT_WEBVIEW_BASE_URL = "https://pay.tryblink.xyz";
+var Deposit = class {
+  config;
+  iframe = null;
+  hostedOrigin = null;
+  messageListener = null;
+  requestId = 0;
+  destroyed = false;
+  _status = "idle";
+  _result = null;
+  _error = null;
+  flowTimer = null;
+  lastSignerResponse = null;
+  listeners = {
+    complete: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set(),
+    close: /* @__PURE__ */ new Set(),
+    "status-change": /* @__PURE__ */ new Set()
+  };
+  /** Current phase of the deposit flow. */
+  get status() {
+    return this._status;
+  }
+  /** Last successful {@link DepositResult}, available when `status === 'completed'`. */
+  get result() {
+    return this._result;
+  }
+  /** Last {@link DepositError}, available when `status === 'error'`. */
+  get error() {
+    return this._error;
+  }
+  /** Whether a deposit flow is currently in progress (signer loading or iframe open). */
+  get isActive() {
+    return this._status === "signer-loading" || this._status === "iframe-active";
+  }
+  constructor(config) {
+    if (!config.signer || typeof config.signer !== "string" && typeof config.signer !== "function") {
+      throw new DepositError("INVALID_REQUEST", "DepositConfig.signer is required (URL string or SignerFunction).");
+    }
+    this.config = config;
+    this.log("Deposit instance created", {
+      signer: typeof config.signer === "string" ? config.signer : "<function>"
+    });
+  }
+  /**
+   * Open the hosted payment flow for the given deposit.
+   *
+   * The returned Promise resolves when the user completes the payment and
+   * rejects with a {@link DepositError} on failure.
+   */
+  requestDeposit(request) {
+    if (this.destroyed) {
+      return Promise.reject(
+        new DepositError("INVALID_REQUEST", "This Deposit instance has been destroyed.")
+      );
+    }
+    validateDepositRequest(request);
+    this.log("requestDeposit called", { amount: request.amount, token: request.token, chainId: request.chainId });
+    this.requestId += 1;
+    const currentRequestId = this.requestId;
+    this.cleanup();
+    this._result = null;
+    this._error = null;
+    this.setStatus("signer-loading");
+    return new Promise((resolve, reject) => {
+      const settle = (fn) => {
+        if (this.requestId !== currentRequestId) return;
+        fn();
+      };
+      const onComplete = (result) => {
+        settle(() => {
+          this.cleanup();
+          this._result = result;
+          this._error = null;
+          this.setStatus("completed");
+          this.emit("complete", result);
+          resolve(result);
+        });
+      };
+      const onError = (error) => {
+        settle(() => {
+          this.cleanup();
+          this._error = error;
+          this.setStatus("error");
+          this.emit("error", error);
+          reject(error);
+        });
+      };
+      if (this.config.flowTimeoutMs != null && this.config.flowTimeoutMs > 0) {
+        this.flowTimer = setTimeout(() => {
+          onError(
+            new DepositError(
+              "FLOW_TIMEOUT",
+              `The payment flow did not complete within ${this.config.flowTimeoutMs}ms.`
+            )
+          );
+        }, this.config.flowTimeoutMs);
+      }
+      this.runSignerFlow(request, currentRequestId, onComplete, onError);
+    });
+  }
+  /** Register an event listener. */
+  on(event, handler) {
+    this.listeners[event].add(handler);
+    return this;
+  }
+  /** Remove a previously registered event listener. */
+  off(event, handler) {
+    this.listeners[event].delete(handler);
+    return this;
+  }
+  /** No-op — retained for API compatibility with the popup-based SDK. */
+  focus() {
+  }
+  /** Close the deposit iframe without waiting for completion. */
+  close() {
+    this.log("close() called");
+    this.cleanup();
+    this.setStatus("idle");
+    this.emit("close");
+  }
+  /** Tear down the instance and release all resources. */
+  destroy() {
+    this.log("destroy() called");
+    this.cleanup();
+    this.setStatus("idle");
+    this.destroyed = true;
+    for (const set of Object.values(this.listeners)) {
+      set.clear();
+    }
+  }
+  // ── Private ──────────────────────────────────────────────────────────
+  log(message, data) {
+    if (!this.config.debug) return;
+    if (data) {
+      console.debug(`[BlinkDeposit] ${message}`, data);
+    } else {
+      console.debug(`[BlinkDeposit] ${message}`);
+    }
+  }
+  setStatus(status) {
+    if (this._status === status) return;
+    this.log(`Status: ${this._status} \u2192 ${status}`);
+    this._status = status;
+    this.emit("status-change", status);
+  }
+  async runSignerFlow(request, requestId, onComplete, onError) {
+    try {
+      const webviewBaseUrl = this.config.webviewBaseUrl ?? DEFAULT_WEBVIEW_BASE_URL;
+      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(() => {
+        onError(
+          new DepositError(
+            "DEPOSIT_DISMISSED",
+            "The deposit was dismissed before the transfer completed."
+          )
+        );
+        this.emit("close");
+      });
+      this.startMessageListener(iframeHandle, onComplete);
+      this.setStatus("iframe-active");
+      this.log("Iframe opened with hosted flow", { url: targetUrl });
+    } catch (err) {
+      if (this.requestId !== requestId) return;
+      this.log("Signer flow failed", { error: err instanceof Error ? err.message : String(err) });
+      if (err instanceof DepositError) {
+        onError(err);
+      } else {
+        onError(
+          new DepositError(
+            "SIGNER_NETWORK_ERROR",
+            err instanceof Error ? err.message : "Unknown signer error."
+          )
+        );
+      }
+    }
+  }
+  startMessageListener(iframeHandle, onComplete) {
+    const handler = (event) => {
+      if (this.hostedOrigin && event.origin !== this.hostedOrigin) {
+        return;
+      }
+      const contentWindow = iframeHandle.contentWindow;
+      if (event.source && contentWindow && event.source !== contentWindow) {
+        return;
+      }
+      if (parseCloseRequest(event.data)) {
+        this.log("Close request received from hosted flow");
+        iframeHandle.close();
+        return;
+      }
+      const message = parseTransferComplete(event.data);
+      if (!message) {
+        return;
+      }
+      this.log("Transfer complete received", { transferId: message.transfer.id, status: message.transfer.status });
+      if (contentWindow) {
+        try {
+          contentWindow.postMessage(
+            buildAckMessage(message.transfer.id),
+            this.hostedOrigin ?? "*"
+          );
+        } catch {
+        }
+      }
+      const depositResult = { transfer: message.transfer };
+      if (this.lastSignerResponse?.preview) {
+        depositResult.idempotencyKey = this.lastSignerResponse.preview.idempotencyKey;
+        depositResult.preview = {
+          amount: this.lastSignerResponse.preview.amount,
+          chainId: this.lastSignerResponse.preview.chainId,
+          address: this.lastSignerResponse.preview.address,
+          token: this.lastSignerResponse.preview.token
+        };
+      }
+      onComplete(depositResult);
+    };
+    this.messageListener = handler;
+    window.addEventListener("message", handler);
+  }
+  cleanup() {
+    if (this.flowTimer) {
+      clearTimeout(this.flowTimer);
+      this.flowTimer = null;
+    }
+    if (this.messageListener) {
+      window.removeEventListener("message", this.messageListener);
+      this.messageListener = null;
+    }
+    if (this.iframe) {
+      this.iframe.destroy();
+      this.iframe = null;
+    }
+    this.hostedOrigin = null;
+    this.lastSignerResponse = null;
+  }
+  emit(event, ...args) {
+    for (const handler of this.listeners[event]) {
+      try {
+        handler(...args);
+      } catch {
+      }
+    }
+  }
+};
+var Checkout = Deposit;
+
+export { Checkout, CheckoutError2 as CheckoutError, DEFAULT_WEBVIEW_BASE_URL, Deposit, DepositError, getDisplayMessage };
+//# sourceMappingURL=chunk-RG2MWY2W.js.map
+//# sourceMappingURL=chunk-RG2MWY2W.js.map