@blocklet/payment-react-headless 1.26.0

package/es/checkout/types.d.ts

@@ -0,0 +1,262 @@
+import type { TLineItemExpanded, TPaymentMethodExpanded, TPaymentCurrency, TPrice, TCheckoutSessionExpanded, TPaymentIntent, TCustomer } from '@blocklet/payment-types';
+export type SubmitStatus = 'idle' | 'submitting' | 'confirming_price' | 'confirming_fast_pay' | 'credit_insufficient' | 'waiting_did' | 'waiting_stripe' | 'completed' | 'failed';
+export type SubmitContext = {
+    type: 'price_change';
+    changePercent: number;
+} | {
+    type: 'fast_pay';
+    payType: 'balance' | 'delegation' | 'credit';
+    amount: string;
+    payer: string;
+} | {
+    type: 'credit_insufficient';
+    available: string;
+    required: string;
+} | {
+    type: 'stripe';
+    clientSecret: string;
+    intentType?: 'payment_intent' | 'setup_intent';
+} | {
+    type: 'did_connect';
+    action: string;
+    checkpointId: string;
+    extraParams: Record<string, unknown>;
+} | {
+    type: 'error';
+    message: string;
+    code?: string;
+} | null;
+export interface FieldConfig {
+    name: string;
+    type: 'text' | 'email' | 'phone' | 'select' | 'country';
+    required: boolean;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    group?: string;
+}
+export type CheckoutFormData = {
+    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 type CheckoutResult = {
+    checkoutSession: TCheckoutSessionExpanded;
+    paymentMethods: TPaymentMethodExpanded[];
+    paymentIntent?: TPaymentIntent;
+    customer?: TCustomer;
+    quotes?: Record<string, {
+        quote_id: string;
+        expires_at: number;
+        quoted_amount: string;
+        exchange_rate?: string;
+        rate_provider_name?: string;
+        rate_provider_id?: string;
+    }>;
+    rateUnavailable?: boolean;
+};
+export interface UseCheckoutReturn {
+    isLoading: boolean;
+    error: string | null;
+    /** Structured error code: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null */
+    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+    refresh: () => Promise<void>;
+    vendorCount: number;
+    product: {
+        name: string;
+        description: string;
+        images: string[];
+        features: Array<{
+            name: string;
+            icon?: string;
+        }>;
+        billing: {
+            mode: 'payment' | 'subscription';
+            interval: 'month' | 'year' | 'week' | 'day' | null;
+            intervalCount: number;
+            displayInterval: string;
+        };
+        metadata: Record<string, string>;
+    } | null;
+    lineItems: {
+        items: Array<TLineItemExpanded & {
+            adjustable_quantity?: {
+                enabled: boolean;
+                minimum?: number;
+                maximum?: number;
+            };
+        }>;
+        updateQuantity: (itemId: string, qty: number) => Promise<void>;
+        upsell: (fromId: string, toId: string) => Promise<void>;
+        downsell: (priceId: string) => Promise<void>;
+        billingInterval: {
+            current: 'month' | 'year' | 'week' | 'day' | null;
+            available: Array<{
+                interval: 'month' | 'year' | 'week' | 'day';
+                priceId: string;
+                amount: string;
+                savings: string | null;
+            }>;
+            switch: (interval: 'month' | 'year' | 'week' | 'day') => Promise<void>;
+        } | null;
+        crossSellItem: TPrice | null;
+        crossSellRequired: boolean;
+        addCrossSell: () => Promise<void>;
+        removeCrossSell: () => Promise<void>;
+    };
+    paymentMethod: {
+        current: TPaymentMethodExpanded;
+        currency: TPaymentCurrency;
+        available: TPaymentMethodExpanded[];
+        currencies: TPaymentCurrency[];
+        isStripe: boolean;
+        isCrypto: boolean;
+        isCredit: boolean;
+        setType: (type: 'stripe' | 'crypto') => Promise<void>;
+        types: Array<{
+            type: 'stripe' | 'crypto';
+            label: string;
+            currencies: TPaymentCurrency[];
+            active: boolean;
+        }>;
+        setCurrency: (currencyId: string) => Promise<void>;
+    };
+    stripe: {
+        publishableKey: string | null;
+        clientSecret: string | null;
+        status: 'idle' | 'ready' | 'processing' | 'succeeded' | 'failed';
+    } | null;
+    pricing: {
+        subtotal: string;
+        discount: string | null;
+        tax: {
+            amount: string;
+            rate: number;
+            inclusive: boolean;
+        } | null;
+        staking: string | null;
+        total: string;
+        usdEquivalent: string | null;
+        hasDynamicPricing: boolean;
+        rate: {
+            value: string | null;
+            display: string | null;
+            provider: string | null;
+            providerDisplay: string | null;
+            fetchedAt: number | null;
+            status: 'loading' | 'available' | 'unavailable';
+            refresh: () => Promise<void>;
+        };
+        quote: {
+            locked: boolean;
+            lockedAt: number | null;
+            expiresAt: number | null;
+            expired: boolean;
+            baseCurrency: string | null;
+        };
+        slippage: {
+            percent: number;
+            set: (config: {
+                mode: string;
+                percent: number;
+            }) => Promise<void>;
+        };
+        promotion: {
+            applied: boolean;
+            code: string | null;
+            active: boolean;
+            inactiveReason: string | null;
+            apply: (code: string) => Promise<{
+                success: boolean;
+                error?: string;
+            }>;
+            remove: () => Promise<void>;
+        };
+        trial: {
+            active: boolean;
+            days: number;
+            afterTrialPrice: string | null;
+            afterTrialInterval: string | null;
+        };
+    };
+    form: {
+        fields: FieldConfig[];
+        values: CheckoutFormData;
+        onChange: (field: string, value: string | boolean | Record<string, string>) => void;
+        errors: Partial<Record<string, string>>;
+        touched: Record<string, boolean>;
+        validate: () => Promise<boolean>;
+        validateField: (field: string) => Promise<void>;
+    };
+    submit: {
+        status: SubmitStatus;
+        context: SubmitContext;
+        execute: () => Promise<void>;
+        confirm: () => Promise<void>;
+        cancel: () => void;
+        result: CheckoutResult | null;
+        retry: () => Promise<void>;
+        reset: () => void;
+        stripeConfirm: () => Promise<void>;
+        stripeCancel: () => Promise<void>;
+        vendorStatus: {
+            payment_status: string;
+            session_status: string;
+            vendors: Array<{
+                success: boolean;
+                status: 'delivered' | 'pending' | 'failed';
+                progress: number;
+                message: string;
+                appUrl?: string;
+                title?: string;
+                name?: string;
+                vendorType: string;
+            }>;
+            error: string | null;
+            isAllCompleted: boolean;
+            hasFailed: boolean;
+        } | null;
+    };
+    subscription: {
+        mode: 'payment' | 'subscription' | 'setup';
+        showStake: boolean;
+        confirmMessage: string;
+    } | null;
+    pageInfo: {
+        formPurposeDescription?: {
+            en: string;
+            zh: string;
+        };
+        showProductFeatures: boolean;
+    } | null;
+    canSubmit: boolean;
+    isCompleted: boolean;
+    isDonation: boolean;
+    setDonationAmount: (priceId: string, amount: string) => Promise<void>;
+    customer: {
+        name: string;
+        email: string;
+        phone: string;
+        address: {
+            country: string;
+            state: string;
+            city: string;
+            line1: string;
+            line2: string;
+            postal_code: string;
+        };
+    } | null;
+    livemode: boolean;
+    session: TCheckoutSessionExpanded | null;
+}

package/es/index.d.ts

@@ -0,0 +1 @@
+export { type UseCheckoutReturn, type SubmitStatus, type SubmitContext, type FieldConfig, type CheckoutFormData, type CheckoutResult, type UseCheckoutSessionReturn, type SessionData, type UsePaymentMethodReturn, type UsePricingReturn, type UseCustomerFormReturn, type UseSubmitReturn, type UseProductReturn, type UseLineItemsReturn, type UseBillingIntervalReturn, type BillingIntervalData, type UseUpsellReturn, type UseCrossSellReturn, type UsePromotionReturn, type UseExchangeRateReturn, type UseSlippageReturn, type UseCheckoutStatusReturn, type UsePricingFeatureReturn, type CheckoutProviderProps, CheckoutProvider, useSessionContext, usePaymentMethodContext, useExchangeRateContext, useCustomerFormContext, useSubmitContext, useCheckout, useCheckoutSession, usePaymentMethod, usePricing, useCustomerForm, useSubmit, useProduct, useLineItems, useBillingInterval, useUpsell, useCrossSell, usePromotion, useExchangeRate, useSlippage, useCheckoutStatus, usePricingFeature, usePaymentMethodFeature, useCustomerFormFeature, useSubmitFeature, getPriceUnitAmountByCurrency, } from './checkout';

package/es/index.js

@@ -0,0 +1,28 @@
+export {
+  CheckoutProvider,
+  useSessionContext,
+  usePaymentMethodContext,
+  useExchangeRateContext,
+  useCustomerFormContext,
+  useSubmitContext,
+  useCheckout,
+  useCheckoutSession,
+  usePaymentMethod,
+  usePricing,
+  useCustomerForm,
+  useSubmit,
+  useProduct,
+  useLineItems,
+  useBillingInterval,
+  useUpsell,
+  useCrossSell,
+  usePromotion,
+  useExchangeRate,
+  useSlippage,
+  useCheckoutStatus,
+  usePricingFeature,
+  usePaymentMethodFeature,
+  useCustomerFormFeature,
+  useSubmitFeature,
+  getPriceUnitAmountByCurrency
+} from "./checkout/index.js";

package/es/shared/api.d.ts

@@ -0,0 +1,41 @@
+declare global {
+    interface Window {
+        blocklet?: {
+            prefix?: string;
+            componentId?: string;
+            componentMountPoints?: Array<{
+                did: string;
+                mountPoint: string;
+            }>;
+            appName?: string;
+            languages?: string[];
+        };
+        __PAYMENT_KIT_AUTH_TOKEN?: string;
+        __PAYMENT_KIT_BASE_URL?: string;
+    }
+}
+export declare function getPrefix(): string;
+export declare function getLocale(languages?: string[]): string;
+declare const api: import("axios").AxiosInstance;
+export default api;
+export declare const API: {
+    readonly START_PAYMENT_LINK: (id: string) => string;
+    readonly RETRIEVE_SESSION: (id: string) => string;
+    readonly SWITCH_CURRENCY: (id: string) => string;
+    readonly SUBMIT: (id: string) => string;
+    readonly DONATE_SUBMIT: (id: string) => string;
+    readonly FAST_CHECKOUT_CONFIRM: (id: string) => string;
+    readonly EXCHANGE_RATE: (id: string) => string;
+    readonly ADJUST_QUANTITY: (id: string) => string;
+    readonly UPSELL: (id: string) => string;
+    readonly DOWNSELL: (id: string) => string;
+    readonly CROSS_SELL: (id: string) => string;
+    readonly CHANGE_AMOUNT: (id: string) => string;
+    readonly SLIPPAGE: (id: string) => string;
+    readonly ABORT_STRIPE: (id: string) => string;
+    readonly RECALCULATE_PROMOTION_SESSION: (id: string) => string;
+    readonly APPLY_PROMOTION: (id: string) => string;
+    readonly REMOVE_PROMOTION: (id: string) => string;
+    readonly CUSTOMER_ME: "/api/customers/me";
+    readonly VENDOR_ORDER_STATUS: (id: string) => string;
+};

package/es/shared/api.js

@@ -0,0 +1,81 @@
+import { createAxios } from "@blocklet/js-sdk";
+import isNull from "lodash/isNull";
+const PAYMENT_KIT_DID = "z2qaCNvKMv5GjouKdcDWexv6WqtHbpNPQDnAk";
+export function getPrefix() {
+  const prefix = window.blocklet?.prefix || "/";
+  const baseUrl = window.location?.origin;
+  if (window.__PAYMENT_KIT_BASE_URL) {
+    try {
+      const tmp = new URL(window.__PAYMENT_KIT_BASE_URL);
+      if (tmp.origin !== window.location.origin) {
+        return window.__PAYMENT_KIT_BASE_URL;
+      }
+    } catch {
+    }
+  }
+  const componentId = (window.blocklet?.componentId || "").split("/").pop();
+  if (componentId === PAYMENT_KIT_DID) {
+    return `${baseUrl}${prefix}`;
+  }
+  const component = (window.blocklet?.componentMountPoints || []).find((x) => x?.did === PAYMENT_KIT_DID);
+  if (component) {
+    return `${baseUrl}${component.mountPoint}`;
+  }
+  return `${baseUrl}${prefix}`;
+}
+export function getLocale(languages) {
+  if (typeof window === "undefined") return "en";
+  try {
+    const stored = localStorage.getItem("locale");
+    if (stored) return stored;
+  } catch {
+  }
+  if (languages && languages.length > 0) return languages[0];
+  return navigator.language?.split("-")[0] || "en";
+}
+function createApi() {
+  const api2 = createAxios();
+  api2.interceptors.request.use(
+    (config) => {
+      const prefix = getPrefix();
+      config.baseURL = prefix || "";
+      const locale = getLocale(window.blocklet?.languages);
+      const query = new URLSearchParams(config.url?.split("?").pop());
+      config.params = { ...config.params || {}, locale };
+      const authToken = window.__PAYMENT_KIT_AUTH_TOKEN;
+      if (authToken && typeof config.params.authToken === "undefined" && !query.has("authToken")) {
+        config.params.authToken = authToken;
+      }
+      if (typeof config.params.livemode === "undefined" && query.has("livemode") === false) {
+        const livemode = localStorage.getItem("livemode");
+        config.params.livemode = isNull(livemode) ? true : JSON.parse(livemode);
+      }
+      return config;
+    },
+    (err) => Promise.reject(err)
+  );
+  return api2;
+}
+const api = createApi();
+export default api;
+export const API = {
+  START_PAYMENT_LINK: (id) => `/api/checkout-sessions/start/${id}`,
+  RETRIEVE_SESSION: (id) => `/api/checkout-sessions/retrieve/${id}`,
+  SWITCH_CURRENCY: (id) => `/api/checkout-sessions/${id}/switch-currency`,
+  SUBMIT: (id) => `/api/checkout-sessions/${id}/submit`,
+  DONATE_SUBMIT: (id) => `/api/checkout-sessions/${id}/donate-submit`,
+  FAST_CHECKOUT_CONFIRM: (id) => `/api/checkout-sessions/${id}/fast-checkout-confirm`,
+  EXCHANGE_RATE: (id) => `/api/checkout-sessions/${id}/exchange-rate`,
+  ADJUST_QUANTITY: (id) => `/api/checkout-sessions/${id}/adjust-quantity`,
+  UPSELL: (id) => `/api/checkout-sessions/${id}/upsell`,
+  DOWNSELL: (id) => `/api/checkout-sessions/${id}/downsell`,
+  CROSS_SELL: (id) => `/api/checkout-sessions/${id}/cross-sell`,
+  CHANGE_AMOUNT: (id) => `/api/checkout-sessions/${id}/amount`,
+  SLIPPAGE: (id) => `/api/checkout-sessions/${id}/slippage`,
+  ABORT_STRIPE: (id) => `/api/checkout-sessions/${id}/abort-stripe`,
+  RECALCULATE_PROMOTION_SESSION: (id) => `/api/checkout-sessions/${id}/recalculate-promotion`,
+  APPLY_PROMOTION: (id) => `/api/checkout-sessions/${id}/apply-promotion`,
+  REMOVE_PROMOTION: (id) => `/api/checkout-sessions/${id}/remove-promotion`,
+  CUSTOMER_ME: "/api/customers/me",
+  VENDOR_ORDER_STATUS: (id) => `/api/vendors/order/${id}/status`
+};

package/es/shared/format.d.ts

@@ -0,0 +1,38 @@
+import { BN } from '@ocap/util';
+import type { TPaymentCurrency, TPrice, TLineItemExpanded } from '@blocklet/payment-types';
+export declare function formatNumber(n: number | string, precision?: number, trim?: boolean, thousandSeparated?: boolean): string;
+export declare function formatBNStr(str?: string, decimals?: number, precision?: number, trim?: boolean, thousandSeparated?: boolean): string;
+export declare function formatDynamicPrice(n: number | string, isDynamic: boolean, precision?: number, trim?: boolean, thousandSeparated?: boolean): string;
+export declare function getUsdAmountFromTokenUnits(tokenAmount: BN | string, tokenDecimals: number, exchangeRate?: string | null): string | null;
+export declare function formatUsdAmount(amount: string | null, locale?: string): string | null;
+export declare function formatExchangeRate(amount: string | null): string | null;
+export declare function formatExchangeRateDisplay(rate: string | number | null | undefined, currency?: string, decimals?: number): string | null;
+export declare function formatAmount(amount: string, decimals: number, precision?: number): string;
+export declare function getPriceCurrencyOptions(price: TPrice): Array<{
+    currency_id: string;
+    unit_amount: string;
+    custom_unit_amount: {
+        preset?: string;
+        presets: string[];
+    } | null;
+    tiers: unknown;
+}>;
+export declare function getPriceUnitAmountByCurrency(price: TPrice, currency: TPaymentCurrency): string;
+export declare function getLineItemAmounts(item: TLineItemExpanded, currency: TPaymentCurrency, { useUpsell, exchangeRate }?: {
+    useUpsell?: boolean;
+    exchangeRate?: string | null;
+}): {
+    unitAmount: BN;
+    totalAmount: BN;
+    isDynamicQuote: boolean;
+};
+export declare function getCheckoutAmount(items: TLineItemExpanded[], currency: TPaymentCurrency, trialing?: boolean, upsell?: boolean, { exchangeRate }?: {
+    exchangeRate?: string | null;
+}): {
+    subtotal: string;
+    total: string;
+    renew: string;
+    discount: string;
+    shipping: string;
+    tax: string;
+};

package/es/shared/format.js

@@ -0,0 +1,229 @@
+import { BN, fromUnitToToken, fromTokenToUnit } from "@ocap/util";
+export function formatNumber(n, precision = 6, trim = true, thousandSeparated = true) {
+  if (!n || n === "0") {
+    return "0";
+  }
+  const num = Number(n);
+  if (!Number.isFinite(num)) {
+    return "0";
+  }
+  let result;
+  if (thousandSeparated) {
+    result = num.toLocaleString("en-US", {
+      minimumFractionDigits: precision,
+      maximumFractionDigits: precision
+    });
+  } else {
+    result = num.toFixed(precision);
+  }
+  if (!trim) {
+    return result;
+  }
+  const [left, right] = result.split(".");
+  if (!right) return left;
+  const trimmed = right.replace(/0+$/, "");
+  return trimmed ? `${left}.${trimmed}` : left;
+}
+export function formatBNStr(str = "", decimals = 18, precision = 6, trim = true, thousandSeparated = true) {
+  if (!str) {
+    return "0";
+  }
+  return formatNumber(fromUnitToToken(str, decimals), precision, trim, thousandSeparated);
+}
+export function formatDynamicPrice(n, isDynamic, precision = 6, trim = true, thousandSeparated = true) {
+  if (!isDynamic) {
+    return formatNumber(n, precision, trim, thousandSeparated);
+  }
+  const num = Number(n);
+  if (!Number.isFinite(num)) {
+    return formatNumber(n, precision, trim, thousandSeparated);
+  }
+  const abs = Math.abs(num);
+  const targetPrecision = abs > 0 && abs < 0.01 ? precision : 2;
+  return formatNumber(n, targetPrecision, trim, thousandSeparated);
+}
+const USD_DECIMALS = 8;
+export function getUsdAmountFromTokenUnits(tokenAmount, tokenDecimals, exchangeRate) {
+  if (!exchangeRate && exchangeRate !== "0") {
+    return null;
+  }
+  if (tokenDecimals === void 0 || tokenDecimals === null) {
+    return null;
+  }
+  try {
+    const amountBN = tokenAmount instanceof BN ? tokenAmount : new BN(tokenAmount || "0");
+    const tokenScale = new BN(10).pow(new BN(tokenDecimals));
+    if (tokenScale.isZero()) {
+      return null;
+    }
+    const rateBN = new BN(exchangeRate.replace(".", ""));
+    const rateDecimalPlaces = exchangeRate.includes(".") ? exchangeRate.split(".")[1]?.length || 0 : 0;
+    const rateScale = new BN(10).pow(new BN(rateDecimalPlaces));
+    const usdPrecisionScale = new BN(10).pow(new BN(USD_DECIMALS));
+    const usdUnit = amountBN.mul(rateBN).mul(usdPrecisionScale).div(tokenScale.mul(rateScale));
+    return fromUnitToToken(usdUnit.toString(), USD_DECIMALS);
+  } catch {
+    return null;
+  }
+}
+export function formatUsdAmount(amount, locale = "en") {
+  if (!amount && amount !== "0") {
+    return null;
+  }
+  const num = Number(amount);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).format(num);
+}
+export function formatExchangeRate(amount) {
+  if (!amount && amount !== "0") {
+    return null;
+  }
+  const value = String(amount);
+  const num = Number(value);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  return value;
+}
+export function formatExchangeRateDisplay(rate, currency = "USD", decimals = 2) {
+  if (rate === null || rate === void 0) {
+    return null;
+  }
+  const num = Number(rate);
+  if (!Number.isFinite(num)) {
+    return null;
+  }
+  const formattedValue = num.toFixed(decimals);
+  if (currency === "USD") {
+    return `$${formattedValue}`;
+  }
+  return `${formattedValue} ${currency}`;
+}
+export function formatAmount(amount, decimals, precision = 2) {
+  const tokenAmount = fromUnitToToken(amount, decimals);
+  const numericValue = Number(tokenAmount);
+  if (!Number.isFinite(numericValue)) {
+    return formatBNStr(amount, decimals, precision, true, false);
+  }
+  const abs = Math.abs(numericValue);
+  const targetPrecision = abs > 0 && abs < 0.01 ? decimals : 2;
+  return formatNumber(tokenAmount, targetPrecision, true, false);
+}
+export function getPriceCurrencyOptions(price) {
+  if (Array.isArray(price.currency_options)) {
+    return price.currency_options;
+  }
+  return [
+    {
+      currency_id: price.currency_id,
+      unit_amount: price.unit_amount,
+      custom_unit_amount: price.custom_unit_amount || null,
+      tiers: null
+    }
+  ];
+}
+export function getPriceUnitAmountByCurrency(price, currency) {
+  const options = getPriceCurrencyOptions(price);
+  const option = options.find((x) => x.currency_id === currency?.id);
+  if (option) {
+    if (option.custom_unit_amount) {
+      return option.custom_unit_amount.preset || option.custom_unit_amount.presets[0];
+    }
+    return option.unit_amount;
+  }
+  if (price.currency_id === currency?.id) {
+    if (price.custom_unit_amount) {
+      return price.custom_unit_amount.preset || price.custom_unit_amount.presets[0];
+    }
+    return price.unit_amount;
+  }
+  return "0";
+}
+export function getLineItemAmounts(item, currency, { useUpsell = true, exchangeRate = null } = {}) {
+  if (!currency) {
+    return { unitAmount: new BN(0), totalAmount: new BN(0), isDynamicQuote: false };
+  }
+  const price = useUpsell ? item.upsell_price || item.price : item.price;
+  const quantity = new BN(item.quantity || 0);
+  const quoteAmount = item.quoted_amount;
+  const quoteCurrencyId = item.quote_currency_id;
+  const isDynamicPrice = price?.pricing_type === "dynamic";
+  const isQuoteValidForCurrency = isDynamicPrice && quoteAmount && quoteCurrencyId === currency.id;
+  if (isQuoteValidForCurrency) {
+    const totalAmount = new BN(quoteAmount || "0");
+    const unitAmount2 = quantity.gt(new BN(0)) ? totalAmount.add(quantity).sub(new BN(1)).div(quantity) : new BN(0);
+    return { unitAmount: unitAmount2, totalAmount, isDynamicQuote: true };
+  }
+  if (isDynamicPrice && exchangeRate && price?.base_amount) {
+    const rate = Number(exchangeRate);
+    if (rate > 0 && Number.isFinite(rate)) {
+      const baseAmountUsd = Number(price.base_amount);
+      if (baseAmountUsd > 0 && Number.isFinite(baseAmountUsd)) {
+        const tokenAmount = baseAmountUsd / rate;
+        const unitAmount2 = fromTokenToUnit(tokenAmount.toFixed(currency.decimal || 8), currency.decimal || 8);
+        return {
+          unitAmount: unitAmount2,
+          totalAmount: unitAmount2.mul(quantity),
+          isDynamicQuote: false
+        };
+      }
+    }
+  }
+  if (!exchangeRate && price?.base_amount != null) {
+    const baseAmountUsd = Number(price.base_amount);
+    if (baseAmountUsd >= 0 && Number.isFinite(baseAmountUsd)) {
+      const dec = currency.decimal || 2;
+      const unitAmountBN = fromTokenToUnit(baseAmountUsd.toFixed(dec), dec);
+      return {
+        unitAmount: unitAmountBN,
+        totalAmount: unitAmountBN.mul(quantity),
+        isDynamicQuote: false
+      };
+    }
+  }
+  const unitAmount = new BN(getPriceUnitAmountByCurrency(price, currency));
+  return {
+    unitAmount,
+    totalAmount: unitAmount.mul(quantity),
+    isDynamicQuote: false
+  };
+}
+export function getCheckoutAmount(items, currency, trialing = false, upsell = true, { exchangeRate = null } = {}) {
+  let renew = new BN(0);
+  const total = items.filter((x) => {
+    const price = upsell ? x.upsell_price || x.price : x.price;
+    return price != null;
+  }).reduce((acc, x) => {
+    const quoteCurrencyId = x.quote_currency_id;
+    let totalAmount;
+    if (x.custom_amount && quoteCurrencyId && quoteCurrencyId === currency.id) {
+      totalAmount = new BN(x.custom_amount);
+    } else {
+      ({ totalAmount } = getLineItemAmounts(x, currency, { useUpsell: upsell, exchangeRate }));
+    }
+    const price = upsell ? x.upsell_price || x.price : x.price;
+    if (price?.type === "recurring") {
+      renew = renew.add(totalAmount);
+      if (trialing) {
+        return acc;
+      }
+      if (price.recurring?.usage_type === "metered") {
+        return acc;
+      }
+    }
+    return acc.add(totalAmount);
+  }, new BN(0)).toString();
+  return {
+    subtotal: total,
+    total,
+    renew: formatDynamicPrice(renew.toString(), !!exchangeRate),
+    discount: "0",
+    shipping: "0",
+    tax: "0"
+  };
+}