@blocklet/payment-react-headless 1.26.0

package/lib/checkout/core/paymentMethod.d.ts

@@ -0,0 +1,23 @@
+import type { TPaymentMethodExpanded, TPaymentCurrency, TCheckoutSessionExpanded } from '@blocklet/payment-types';
+import type { CheckoutSessionUser } from '../../types/checkout-augmented';
+export type CurrencyWithMethod = TPaymentCurrency & {
+    method?: {
+        id: string;
+        name: string;
+        type: string;
+    };
+};
+export declare function flattenCurrencies(methods: TPaymentMethodExpanded[]): CurrencyWithMethod[];
+export declare function hasDidWallet(user: CheckoutSessionUser | undefined): boolean;
+export declare function getCurrencyStorageKey(did?: string): string;
+export declare function getInitialCurrencyId(session: TCheckoutSessionExpanded | undefined | null, methods: TPaymentMethodExpanded[]): string | null;
+export declare function findMethodAndCurrency(methods: TPaymentMethodExpanded[], currencyId: string | null): {
+    method: TPaymentMethodExpanded | null;
+    currency: TPaymentCurrency | null;
+};
+export declare function buildPaymentTypes(methods: TPaymentMethodExpanded[], currentMethod: TPaymentMethodExpanded | null): {
+    type: "stripe" | "crypto";
+    label: string;
+    currencies: CurrencyWithMethod[];
+    active: boolean;
+}[];

package/lib/checkout/core/paymentMethod.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildPaymentTypes = buildPaymentTypes;
+exports.findMethodAndCurrency = findMethodAndCurrency;
+exports.flattenCurrencies = flattenCurrencies;
+exports.getCurrencyStorageKey = getCurrencyStorageKey;
+exports.getInitialCurrencyId = getInitialCurrencyId;
+exports.hasDidWallet = hasDidWallet;
+function flattenCurrencies(methods) {
+  const out = [];
+  methods.forEach(method => {
+    const currencies = method.payment_currencies || [];
+    currencies.forEach(currency => {
+      const enriched = {
+        ...currency,
+        method: {
+          id: method.id,
+          name: method.name,
+          type: method.type
+        }
+      };
+      out.push(enriched);
+    });
+  });
+  return out;
+}
+function hasDidWallet(user) {
+  const connected = user?.connectedAccounts || user?.extraConfigs?.connectedAccounts || [];
+  return connected.some(x => x.provider === "wallet");
+}
+const CURRENCY_PREFERENCE_KEY = "payment-currency-preference";
+function getCurrencyStorageKey(did) {
+  return did ? `${CURRENCY_PREFERENCE_KEY}:${did}` : CURRENCY_PREFERENCE_KEY;
+}
+function getInitialCurrencyId(session, methods) {
+  if (typeof window !== "undefined") {
+    try {
+      const params = new URLSearchParams(window.location.search);
+      const urlCurrency = params.get("currencyId") || params.get("currency_id");
+      if (urlCurrency) return urlCurrency;
+    } catch {}
+    const user = session?.user;
+    if (user && !hasDidWallet(user)) {
+      const stripeMethod = methods.find(m => m.type === "stripe");
+      const stripeCurrency = stripeMethod?.payment_currencies?.[0];
+      if (stripeCurrency) return stripeCurrency.id;
+    }
+    try {
+      const did = session?.user?.did;
+      const stored = localStorage.getItem(getCurrencyStorageKey(did));
+      if (stored) return stored;
+    } catch {}
+  }
+  return session?.currency_id || null;
+}
+function findMethodAndCurrency(methods, currencyId) {
+  if (!currencyId) {
+    const first2 = methods[0];
+    const firstCurrency = first2?.payment_currencies?.[0] || null;
+    return {
+      method: first2 || null,
+      currency: firstCurrency
+    };
+  }
+  for (const method of methods) {
+    for (const currency of method.payment_currencies || []) {
+      if (currency.id === currencyId) {
+        return {
+          method,
+          currency
+        };
+      }
+    }
+  }
+  const first = methods[0];
+  return {
+    method: first || null,
+    currency: first?.payment_currencies?.[0] || null
+  };
+}
+function buildPaymentTypes(methods, currentMethod) {
+  const typeMap = /* @__PURE__ */new Map();
+  methods.forEach(method => {
+    const type = method.type === "stripe" ? "stripe" : "crypto";
+    if (!typeMap.has(type)) {
+      typeMap.set(type, {
+        currencies: [],
+        active: false
+      });
+    }
+    const entry = typeMap.get(type);
+    const enriched = (method.payment_currencies || []).map(cur => ({
+      ...cur,
+      method: {
+        id: method.id,
+        name: method.name,
+        type: method.type
+      }
+    }));
+    entry.currencies.push(...enriched);
+    if (method === currentMethod) {
+      entry.active = true;
+    }
+  });
+  return Array.from(typeMap.entries()).map(([type, data]) => ({
+    type,
+    label: type === "stripe" ? "Card" : "Crypto",
+    currencies: data.currencies,
+    active: data.active
+  }));
+}

package/lib/checkout/core/pricing.d.ts

@@ -0,0 +1,32 @@
+import type { TCheckoutSessionExpanded, TPaymentCurrency, TLineItemExpanded } from '@blocklet/payment-types';
+import type { SessionData } from '../hooks/useCheckoutSession';
+export interface CalculatedAmounts {
+    subtotal: string;
+    paymentAmount: string;
+    total: string;
+    discount: string | null;
+    tax: {
+        amount: string;
+        rate: number;
+        inclusive: boolean;
+    } | null;
+    staking: string | null;
+    usdEquivalent: string | null;
+    subtotalUsdEquivalent?: string | null;
+}
+export declare function calculateAmounts(items: TLineItemExpanded[], currency: TPaymentCurrency | null, session: TCheckoutSessionExpanded | undefined | null, exchangeRate: string | null, hasDynamicPricing: boolean, paymentMethodType?: string | null): CalculatedAmounts;
+export interface QuoteMeta {
+    locked: boolean;
+    lockedAt: number | null;
+    expiresAt: number | null;
+    expired: boolean;
+    baseCurrency: string | null;
+    slippagePercent: number | null;
+}
+export declare function calculateQuoteMeta(items: TLineItemExpanded[], hasDynamicPricing: boolean, sessionData: SessionData | null): QuoteMeta;
+export declare function calculateTrial(session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, items: TLineItemExpanded[], currency: TPaymentCurrency | null, hasDynamicPricing: boolean, exchangeRate: string | null): {
+    active: boolean;
+    days: number;
+    afterTrialPrice: string | null;
+    afterTrialInterval: string | null;
+};

package/lib/checkout/core/pricing.js

@@ -0,0 +1,216 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateAmounts = calculateAmounts;
+exports.calculateQuoteMeta = calculateQuoteMeta;
+exports.calculateTrial = calculateTrial;
+var _util = require("@ocap/util");
+var _format = require("../../shared/format");
+function getStakingSetup(items, currency, billingThreshold = 0) {
+  const staking = {
+    licensed: new _util.BN(0),
+    metered: new _util.BN(0)
+  };
+  const recurringItems = items.map(x => x.upsell_price || x.price).filter(x => x?.type === "recurring" && x?.recurring);
+  if (recurringItems.length > 0) {
+    if (+billingThreshold) {
+      return (0, _util.fromTokenToUnit)(billingThreshold, currency.decimal).toString();
+    }
+    items.forEach(x => {
+      const price = x.upsell_price || x.price;
+      const unit = (0, _format.getPriceUnitAmountByCurrency)(price, currency);
+      const amount = new _util.BN(unit).mul(new _util.BN(x.quantity));
+      if (price?.type === "recurring" && price?.recurring) {
+        if (price.recurring.usage_type === "licensed") {
+          staking.licensed = staking.licensed.add(amount);
+        }
+        if (price.recurring.usage_type === "metered") {
+          staking.metered = staking.metered.add(amount);
+        }
+      }
+    });
+    return staking.licensed.add(staking.metered).toString();
+  }
+  return "0";
+}
+function calculateCouponDiscount(items, currency, session, hasDynamicPricing, exchangeRate, trialing, recurringOnly) {
+  const discounts = session?.discounts || [];
+  if (discounts.length === 0) return new _util.BN(0);
+  const coupon = discounts[0].coupon_details || {};
+  if (recurringOnly && coupon.duration === "once") return new _util.BN(0);
+  const discountableItems = items.filter(item => {
+    if (item.discountable === false) return false;
+    const price = item.upsell_price || item.price;
+    if (price?.recurring?.usage_type === "metered") return false;
+    return true;
+  });
+  const discountableResult = (0, _format.getCheckoutAmount)(discountableItems, currency, trialing, true, {
+    exchangeRate: hasDynamicPricing ? exchangeRate : null
+  });
+  const discountableSubtotalBN = new _util.BN(discountableResult.total);
+  if (discountableSubtotalBN.lte(new _util.BN(0))) return new _util.BN(0);
+  if (coupon.percent_off && coupon.percent_off > 0) {
+    return discountableSubtotalBN.mul(new _util.BN(coupon.percent_off)).div(new _util.BN(100));
+  }
+  if (coupon.amount_off && coupon.amount_off !== "0") {
+    const amountOff = coupon.currency_options?.[currency.id]?.amount_off || coupon.amount_off;
+    if (amountOff && amountOff !== "0") {
+      const amountOffBN = new _util.BN(amountOff);
+      return amountOffBN.lt(discountableSubtotalBN) ? amountOffBN : discountableSubtotalBN;
+    }
+  }
+  return new _util.BN(0);
+}
+function calculateAmounts(items, currency, session, exchangeRate, hasDynamicPricing, paymentMethodType) {
+  if (!currency || items.length === 0) {
+    return {
+      subtotal: "0",
+      paymentAmount: "0",
+      total: "0",
+      discount: null,
+      tax: null,
+      staking: null,
+      usdEquivalent: null
+    };
+  }
+  const subData = session?.subscription_data;
+  const trialDays = Number(subData?.trial_period_days || 0);
+  const trialing = trialDays > 0;
+  const result = (0, _format.getCheckoutAmount)(items, currency, trialing, true, {
+    exchangeRate: hasDynamicPricing ? exchangeRate : null
+  });
+  const subtotalBN = new _util.BN(result.total);
+  const subtotalFormatted = (0, _format.formatDynamicPrice)((0, _util.fromUnitToToken)(subtotalBN, currency.decimal), hasDynamicPricing);
+  const discountBN = calculateCouponDiscount(items, currency, session, hasDynamicPricing, exchangeRate, trialing, false);
+  const discount = discountBN.gt(new _util.BN(0)) ? (0, _format.formatDynamicPrice)((0, _util.fromUnitToToken)(discountBN.toString(), currency.decimal), hasDynamicPricing) : null;
+  const taxAmount = session?.total_details?.amount_tax;
+  const taxBN = new _util.BN(taxAmount || "0");
+  const totalDetails = session?.total_details;
+  const tax = taxAmount && taxAmount !== "0" ? {
+    amount: (0, _util.fromUnitToToken)(taxAmount, currency.decimal),
+    rate: totalDetails?.tax_rate || 0,
+    inclusive: totalDetails?.tax_inclusive || false
+  } : null;
+  const noStake = subData?.no_stake || false;
+  const billingThreshold = Math.max(Number(subData?.billing_threshold_amount || 0), Number(subData?.min_stake_amount || 0));
+  const shouldShowStaking = paymentMethodType === "arcblock" && currency.type !== "credit" && !noStake;
+  const stakingUnitStr = shouldShowStaking ? getStakingSetup(items, currency, billingThreshold) : "0";
+  const stakingBN = new _util.BN(stakingUnitStr);
+  const subtotalWithStakingBN = subtotalBN.add(stakingBN);
+  let totalBN = subtotalWithStakingBN.sub(discountBN);
+  if (taxBN.gt(new _util.BN(0)) && !tax?.inclusive) {
+    totalBN = totalBN.add(taxBN);
+  }
+  if (totalBN.isNeg()) {
+    totalBN = new _util.BN(0);
+  }
+  const totalFormatted = (0, _format.formatDynamicPrice)((0, _util.fromUnitToToken)(totalBN, currency.decimal), hasDynamicPricing);
+  const displaySubtotalBN = subtotalWithStakingBN;
+  const displaySubtotalFormatted = (0, _format.formatDynamicPrice)((0, _util.fromUnitToToken)(displaySubtotalBN, currency.decimal), hasDynamicPricing);
+  let usdEquivalent = null;
+  let subtotalUsdEquivalent = null;
+  if (hasDynamicPricing && exchangeRate && currency) {
+    const totalUsd = (0, _format.getUsdAmountFromTokenUnits)(totalBN.toString(), currency.decimal, exchangeRate);
+    if (totalUsd) {
+      usdEquivalent = (0, _format.formatUsdAmount)(totalUsd) || null;
+    }
+    const subtotalUsd = (0, _format.getUsdAmountFromTokenUnits)(displaySubtotalBN.toString(), currency.decimal, exchangeRate);
+    if (subtotalUsd) {
+      subtotalUsdEquivalent = (0, _format.formatUsdAmount)(subtotalUsd) || null;
+    }
+  }
+  const stakingFormatted = stakingBN.gt(new _util.BN(0)) ? `${(0, _format.formatDynamicPrice)((0, _util.fromUnitToToken)(stakingBN.toString(), currency.decimal), hasDynamicPricing)} ${currency.symbol}` : null;
+  return {
+    subtotal: `${displaySubtotalFormatted} ${currency.symbol}`,
+    paymentAmount: `${subtotalFormatted} ${currency.symbol}`,
+    total: `${totalFormatted} ${currency.symbol}`,
+    discount: discount ? `${discount} ${currency.symbol}` : null,
+    tax,
+    staking: stakingFormatted,
+    usdEquivalent: usdEquivalent ? `$${usdEquivalent}` : null,
+    subtotalUsdEquivalent: subtotalUsdEquivalent ? `$${subtotalUsdEquivalent}` : null
+  };
+}
+function calculateQuoteMeta(items, hasDynamicPricing, sessionData) {
+  if (!items.length || !hasDynamicPricing) {
+    return {
+      locked: false,
+      lockedAt: null,
+      expiresAt: null,
+      expired: false,
+      baseCurrency: null,
+      slippagePercent: null
+    };
+  }
+  const session = sessionData?.checkoutSession;
+  let baseCurrency = null;
+  let expiresAt = null;
+  let slippagePercent = null;
+  items.forEach(item => {
+    const price = item.upsell_price || item.price;
+    if (!baseCurrency && price?.base_currency) baseCurrency = price.base_currency;
+    const expires = item.expires_at;
+    if (expires) {
+      expiresAt = expiresAt === null ? expires : Math.min(expiresAt, expires);
+    }
+    const itemSlippage = item.slippage_percent;
+    if (slippagePercent === null && Number.isFinite(Number(itemSlippage))) {
+      slippagePercent = Number(itemSlippage);
+    }
+  });
+  const piCreated = sessionData?.paymentIntent?.created_at ? new Date(sessionData.paymentIntent.created_at).getTime() : null;
+  const sessionLock = session?.quote_locked_at;
+  const lockedAt = piCreated || sessionLock || null;
+  const locked = !!lockedAt;
+  const now = Date.now();
+  const expired = expiresAt ? now > expiresAt : false;
+  return {
+    locked,
+    lockedAt,
+    expiresAt,
+    expired,
+    baseCurrency,
+    slippagePercent
+  };
+}
+function calculateTrial(session, currencyId, items, currency, hasDynamicPricing, exchangeRate) {
+  const subData = session?.subscription_data;
+  let trialDays = Number(subData?.trial_period_days || 0);
+  if (trialDays > 0 && currencyId) {
+    const trialCurrencyIds = (subData?.trial_currency || "").split(",").map(s => s.trim()).filter(Boolean);
+    if (trialCurrencyIds.length > 0 && !trialCurrencyIds.includes(currencyId)) {
+      trialDays = 0;
+    }
+  }
+  const trialActive = trialDays > 0;
+  let afterTrialPrice = null;
+  let afterTrialInterval = null;
+  if (trialActive && currency && items.length > 0) {
+    const noTrialResult = (0, _format.getCheckoutAmount)(items, currency, false, true, {
+      exchangeRate: hasDynamicPricing ? exchangeRate : null
+    });
+    let afterTrialBN = new _util.BN(noTrialResult.total);
+    const recurringDiscount = calculateCouponDiscount(items, currency, session, hasDynamicPricing, exchangeRate, false, true);
+    if (recurringDiscount.gt(new _util.BN(0))) {
+      afterTrialBN = afterTrialBN.sub(recurringDiscount);
+      if (afterTrialBN.isNeg()) afterTrialBN = new _util.BN(0);
+    }
+    afterTrialPrice = `${(0, _format.formatDynamicPrice)((0, _util.fromUnitToToken)(afterTrialBN, currency.decimal), hasDynamicPricing)} ${currency.symbol}`;
+    const recurringItem = items.find(item => {
+      const price = item.upsell_price || item.price;
+      return price?.type === "recurring" && price?.recurring;
+    });
+    if (recurringItem) {
+      const price = recurringItem.upsell_price || recurringItem.price;
+      afterTrialInterval = price?.recurring?.interval || null;
+    }
+  }
+  return {
+    active: trialActive,
+    days: trialDays,
+    afterTrialPrice,
+    afterTrialInterval
+  };
+}

package/lib/checkout/core/promotion.d.ts

@@ -0,0 +1,10 @@
+import type { TCheckoutSessionExpanded } from '@blocklet/payment-types';
+export declare function extractPromotionCodeFromSession(session: TCheckoutSessionExpanded | undefined | null): string | null;
+export declare function applyPromotionCode(sessionId: string, code: string, currencyId: string | null | undefined): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export declare function removePromotionCode(sessionId: string): Promise<void>;
+export declare function recalculatePromotion(sessionId: string, currencyId: string | null | undefined): Promise<void>;
+export declare function isPromotionActive(session: TCheckoutSessionExpanded | undefined | null): boolean;
+export declare function hasAppliedDiscounts(session: TCheckoutSessionExpanded | undefined | null): boolean;

package/lib/checkout/core/promotion.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyPromotionCode = applyPromotionCode;
+exports.extractPromotionCodeFromSession = extractPromotionCodeFromSession;
+exports.hasAppliedDiscounts = hasAppliedDiscounts;
+exports.isPromotionActive = isPromotionActive;
+exports.recalculatePromotion = recalculatePromotion;
+exports.removePromotionCode = removePromotionCode;
+var _api = _interopRequireWildcard(require("../../shared/api"));
+var _checkoutAugmented = require("../../types/checkout-augmented");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function extractPromotionCodeFromSession(session) {
+  const discounts = session?.discounts || [];
+  if (discounts.length === 0) return null;
+  const firstDiscount = discounts[0];
+  const details = firstDiscount.promotion_code_details;
+  const verification = firstDiscount.verification_data;
+  return details?.code || verification?.code || firstDiscount.promotion_code || firstDiscount.coupon || null;
+}
+async function applyPromotionCode(sessionId, code, currencyId) {
+  try {
+    const {
+      data
+    } = await _api.default.post(_api.API.APPLY_PROMOTION(sessionId), {
+      promotion_code: code,
+      currency_id: currencyId
+    });
+    if (data.error) {
+      return {
+        success: false,
+        error: data.error
+      };
+    }
+    return {
+      success: true
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: (0, _checkoutAugmented.getErrorMessage)(err) || "Invalid promotion code"
+    };
+  }
+}
+async function removePromotionCode(sessionId) {
+  await _api.default.delete(_api.API.REMOVE_PROMOTION(sessionId));
+}
+async function recalculatePromotion(sessionId, currencyId) {
+  await _api.default.post(_api.API.RECALCULATE_PROMOTION_SESSION(sessionId), {
+    currency_id: currencyId
+  });
+}
+function isPromotionActive(session) {
+  return session?.allow_promotion_codes !== false;
+}
+function hasAppliedDiscounts(session) {
+  const discounts = session?.discounts || [];
+  return discounts.length > 0;
+}

package/lib/checkout/core/session.d.ts

@@ -0,0 +1,26 @@
+import type { TCheckoutSessionExpanded } from '@blocklet/payment-types';
+export declare function parseProduct(session: TCheckoutSessionExpanded): {
+    name: string;
+    description: string;
+    images: any[];
+    features: {
+        name: string;
+        icon: string | undefined;
+    }[];
+    billing: {
+        mode: "payment" | "subscription";
+        interval: "month" | "year" | "week" | "day" | null;
+        intervalCount: number;
+        displayInterval: string;
+    };
+    metadata: Record<string, any>;
+} | null;
+export declare function parseSubscription(session: TCheckoutSessionExpanded): {
+    mode: "payment" | "subscription" | "setup";
+    showStake: boolean;
+    confirmMessage: string;
+} | null;
+export declare function parsePageInfo(session: TCheckoutSessionExpanded): {
+    formPurposeDescription: any;
+    showProductFeatures: boolean;
+};

package/lib/checkout/core/session.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parsePageInfo = parsePageInfo;
+exports.parseProduct = parseProduct;
+exports.parseSubscription = parseSubscription;
+function parseProduct(session) {
+  const items = session.line_items || [];
+  if (items.length === 0) return null;
+  const firstItem = items[0];
+  const price = firstItem.upsell_price || firstItem.price;
+  const product = price?.product;
+  if (!product) return null;
+  const recurring = price?.recurring;
+  const mode = session.mode === "subscription" ? "subscription" : "payment";
+  const intervalMap = {
+    day: "daily",
+    week: "weekly",
+    month: "monthly",
+    year: "yearly"
+  };
+  return {
+    name: product.name || "",
+    description: product.description || "",
+    images: product.images || [],
+    features: (product.features || []).map(f => ({
+      name: f.name || "",
+      icon: f.icon
+    })),
+    billing: {
+      mode,
+      interval: recurring?.interval || null,
+      intervalCount: recurring?.interval_count || 1,
+      displayInterval: recurring ? intervalMap[recurring.interval] || recurring.interval : ""
+    },
+    metadata: product.metadata || {}
+  };
+}
+function parseSubscription(session) {
+  const subData = session.subscription_data;
+  if (!subData && session.mode === "payment") return null;
+  return {
+    mode: session.mode || "payment",
+    showStake: !subData?.no_stake,
+    confirmMessage: ""
+  };
+}
+function parsePageInfo(session) {
+  const metadata = session.metadata;
+  const pageInfo = metadata?.page_info;
+  const showRaw = metadata?.show_product_features ?? pageInfo?.show_product_features;
+  return {
+    formPurposeDescription: pageInfo?.form_purpose_description,
+    showProductFeatures: `${showRaw}` === "true"
+  };
+}

package/lib/checkout/core/submit.d.ts

@@ -0,0 +1,40 @@
+import type { TCheckoutSessionExpanded } from '@blocklet/payment-types';
+import type { CheckoutFormData } from '../types';
+export declare const QUOTE_ERROR_CODES: readonly ["QUOTE_LOCK_EXPIRED", "QUOTE_AMOUNT_MISMATCH", "QUOTE_EXPIRED_OR_USED", "QUOTE_NOT_FOUND", "QUOTE_REQUIRED", "QUOTE_MAX_PAYABLE_EXCEEDED", "quote_validation_failed"];
+export declare const RELAY_SOCKET_PREFIX = "/.well-known/service/relay";
+export declare function getAppId(): string;
+export declare function getRelayChannel(token: string): string;
+export declare function getRelayProtocol(): string;
+export declare function getSocketHost(): string;
+/**
+ * Compute a fingerprint of the payment context for idempotency key stability.
+ * Key changes only when session state actually changes (quantity, upsell, currency).
+ * Same fingerprint → reuse Quote (intent: "retry with same Quote").
+ */
+export declare function getSessionFingerprint(session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null): string;
+export declare function buildSubmitPayload(sessionId: string, currencyId: string | null, formValues: CheckoutFormData, session: TCheckoutSessionExpanded | undefined | null, priceConfirmed?: boolean, idempotencyKey?: string): {
+    price_confirmed?: boolean | undefined;
+    idempotency_key: string;
+    preview_rate: string | undefined;
+    customer_name: string;
+    customer_email?: string;
+    customer_phone?: string;
+    payment_method: string;
+    payment_currency: string;
+    billing_address?: {
+        country: string;
+        state?: string;
+        city?: string;
+        line1?: string;
+        line2?: string;
+        postal_code: string;
+    };
+};
+export declare function isQuoteError(errorCode: string): boolean;
+export declare function abortStripePayment(sessionId: string): Promise<void>;
+export declare function submitCheckout(sessionId: string, isDonation: boolean, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function confirmFastCheckout(sessionId: string): Promise<Record<string, unknown>>;
+export declare function updateSlippage(sessionId: string, config: {
+    mode: string;
+    percent: number;
+}): Promise<Record<string, unknown>>;

package/lib/checkout/core/submit.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RELAY_SOCKET_PREFIX = exports.QUOTE_ERROR_CODES = void 0;
+exports.abortStripePayment = abortStripePayment;
+exports.buildSubmitPayload = buildSubmitPayload;
+exports.confirmFastCheckout = confirmFastCheckout;
+exports.getAppId = getAppId;
+exports.getRelayChannel = getRelayChannel;
+exports.getRelayProtocol = getRelayProtocol;
+exports.getSessionFingerprint = getSessionFingerprint;
+exports.getSocketHost = getSocketHost;
+exports.isQuoteError = isQuoteError;
+exports.submitCheckout = submitCheckout;
+exports.updateSlippage = updateSlippage;
+var _api = _interopRequireWildcard(require("../../shared/api"));
+var _polling = require("../../shared/polling");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const QUOTE_ERROR_CODES = exports.QUOTE_ERROR_CODES = ["QUOTE_LOCK_EXPIRED", "QUOTE_AMOUNT_MISMATCH", "QUOTE_EXPIRED_OR_USED", "QUOTE_NOT_FOUND", "QUOTE_REQUIRED", "QUOTE_MAX_PAYABLE_EXCEEDED", "quote_validation_failed"];
+const RELAY_SOCKET_PREFIX = exports.RELAY_SOCKET_PREFIX = "/.well-known/service/relay";
+function getAppId() {
+  const blocklet = window.blocklet;
+  return blocklet?.appPid || blocklet?.appId || "";
+}
+function getRelayChannel(token) {
+  return `relay:${getAppId()}:${token}`;
+}
+function getRelayProtocol() {
+  return window.location.protocol === "https:" ? "wss:" : "ws:";
+}
+function getSocketHost() {
+  return new URL(window.location.href).host;
+}
+function getSessionFingerprint(session, currencyId) {
+  if (!session) return "";
+  const items = session.line_items || [];
+  const sig = items.map(i => `${i.upsell_price_id || i.price_id}:${i.quantity}`).join("|");
+  return `${session.id}-${currencyId}-${sig}`;
+}
+function buildSubmitPayload(sessionId, currencyId, formValues, session, priceConfirmed = false, idempotencyKey) {
+  const lineItems = session?.line_items || [];
+  const matchedItem = lineItems.find(item => item.exchange_rate);
+  const previewRate = matchedItem?.exchange_rate;
+  return {
+    ...formValues,
+    idempotency_key: idempotencyKey || (0, _polling.generateIdempotencyKey)(sessionId, currencyId || ""),
+    preview_rate: previewRate || void 0,
+    ...(priceConfirmed && {
+      price_confirmed: true
+    })
+  };
+}
+function isQuoteError(errorCode) {
+  return QUOTE_ERROR_CODES.includes(errorCode) || errorCode === "QUOTE_UPDATED";
+}
+async function abortStripePayment(sessionId) {
+  try {
+    await _api.default.post(_api.API.ABORT_STRIPE(sessionId));
+  } catch {}
+}
+async function submitCheckout(sessionId, isDonation, payload) {
+  const url = isDonation ? _api.API.DONATE_SUBMIT(sessionId) : _api.API.SUBMIT(sessionId);
+  const {
+    data
+  } = await _api.default.put(url, payload);
+  return data;
+}
+async function confirmFastCheckout(sessionId) {
+  const {
+    data
+  } = await _api.default.post(_api.API.FAST_CHECKOUT_CONFIRM(sessionId), {});
+  return data;
+}
+async function updateSlippage(sessionId, config) {
+  const {
+    data
+  } = await _api.default.put(_api.API.SLIPPAGE(sessionId), {
+    slippage_config: config
+  });
+  return data;
+}