@blocklet/payment-react-headless 1.26.1 → 1.26.3

package/src/checkout/context/CheckoutProvider.tsx

@@ -38,12 +38,13 @@ export function CheckoutProvider({ sessionId, children }: CheckoutProviderProps)
 
   const session = sessionData?.checkoutSession;
   const effectiveSessionId = resolvedSessionId || sessionId;
-  const items = (session?.line_items || []) as TLineItemExpanded[];
+  const items = useMemo(() => (session?.line_items || []) as TLineItemExpanded[], [session?.line_items]);
   const isDonation = session?.submit_type === 'donate';
 
   const sessionValue = useMemo<SessionContextValue>(
     () => ({
       sessionData,
+      setSessionData,
       sessionId,
       effectiveSessionId,
       isLoading,
@@ -60,6 +61,7 @@ export function CheckoutProvider({ sessionId, children }: CheckoutProviderProps)
     }),
     [
       sessionData,
+      setSessionData,
       sessionId,
       effectiveSessionId,
       isLoading,
@@ -77,16 +79,22 @@ export function CheckoutProvider({ sessionId, children }: CheckoutProviderProps)
   );
 
   // 2. Payment method layer
-  const paymentMethodHook = usePaymentMethodHook(sessionData, effectiveSessionId, refresh);
+  const paymentMethodHook = usePaymentMethodHook(sessionData, effectiveSessionId, refresh, setSessionData);
 
-  // Recalculate promotion when currency changes
+  // Recalculate promotion when currency changes or on initial mount (if discounts exist).
+  // Uses refresh() (fresh GET) instead of POST response to avoid stale-closure overwrites
+  // when switch-currency and recalculate-promotion race. Matches V1 pattern.
   const prevCurrencyRef = useRef<string | null>(null);
   useEffect(() => {
     const currId = paymentMethodHook.currency?.id || null;
     if (!currId || !session || session.status === 'complete') return;
     if (prevCurrencyRef.current === null || currId !== prevCurrencyRef.current) {
       prevCurrencyRef.current = currId;
-      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then(() => refresh(true));
+      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then((recalculated) => {
+        if (recalculated) {
+          refresh(true);
+        }
+      });
     }
   }, [paymentMethodHook.currency?.id, session?.id]); // eslint-disable-line react-hooks/exhaustive-deps
 
@@ -105,6 +113,7 @@ export function CheckoutProvider({ sessionId, children }: CheckoutProviderProps)
       setCurrency: paymentMethodHook.setCurrency,
       stripe: paymentMethodHook.stripe,
     }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
     [
       paymentMethodHook.current,
       paymentMethodHook.currency,
@@ -134,7 +143,7 @@ export function CheckoutProvider({ sessionId, children }: CheckoutProviderProps)
   const hasDynamicPricing = useMemo(() => checkHasDynamicPricing(items), [items]);
 
   const fetchRate = useMemoizedFn(async () => {
-    if (!effectiveSessionId || !hasDynamicPricing || paymentMethodHook.isStripe) {
+    if (!effectiveSessionId || !hasDynamicPricing || paymentMethodHook.isStripe || paymentMethodHook.switching) {
       setRateStatus(hasDynamicPricing ? 'unavailable' : 'available');
       if (paymentMethodHook.isStripe) {
         setExchangeRate(null);
@@ -175,7 +184,13 @@ export function CheckoutProvider({ sessionId, children }: CheckoutProviderProps)
   useEffect(() => {
     mountedRef.current = true;
 
-    if (!hasDynamicPricing || paymentMethodHook.isStripe || !effectiveSessionId || session?.status === 'complete') {
+    if (
+      !hasDynamicPricing ||
+      paymentMethodHook.isStripe ||
+      paymentMethodHook.switching ||
+      !effectiveSessionId ||
+      session?.status === 'complete'
+    ) {
       // Clear stale rate when switching to Stripe
       if (paymentMethodHook.isStripe) {
         setExchangeRate(null);
@@ -183,16 +198,14 @@ export function CheckoutProvider({ sessionId, children }: CheckoutProviderProps)
         setRateProviderDisplay(null);
         setRateFetchedAt(null);
       }
-      // When session is complete and we already have a rate, keep it as 'available'
-      // (the rate used at payment time is still valid for display).
-      // Otherwise set appropriate status:
-      // - non-dynamic → 'available' (no rate needed)
-      // - dynamic but Stripe or no session → 'unavailable'
-      if (session?.status === 'complete') {
-        // Completed session: rate is irrelevant, suppress unavailable warnings
-        setRateStatus('available');
-      } else {
-        setRateStatus(hasDynamicPricing ? 'unavailable' : 'available');
+      // Don't change rate status during currency switch — keep current rate visible
+      // to avoid triggering "unavailable" toast while switch is in progress.
+      if (!paymentMethodHook.switching) {
+        if (session?.status === 'complete') {
+          setRateStatus('available');
+        } else {
+          setRateStatus(hasDynamicPricing ? 'unavailable' : 'available');
+        }
       }
       return undefined;
     }
@@ -219,7 +232,15 @@ export function CheckoutProvider({ sessionId, children }: CheckoutProviderProps)
       if (intervalRef.current) clearInterval(intervalRef.current);
       document.removeEventListener('visibilitychange', handleVisibility);
     };
-  }, [hasDynamicPricing, paymentMethodHook.isStripe, effectiveSessionId, paymentMethodHook.currency?.id, session?.status]); // eslint-disable-line react-hooks/exhaustive-deps
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    hasDynamicPricing,
+    paymentMethodHook.isStripe,
+    paymentMethodHook.switching,
+    effectiveSessionId,
+    paymentMethodHook.currency?.id,
+    session?.status,
+  ]);
 
   const exchangeRateValue = useMemo<ExchangeRateContextValue>(
     () => ({

package/src/checkout/context/SessionContext.ts

@@ -4,11 +4,13 @@ import type { SessionData } from '../hooks/useCheckoutSession';
 
 export interface SessionContextValue {
   sessionData: SessionData | null;
+  /** Directly replace session data (e.g. using PUT response to skip redundant GET) */
+  setSessionData: (data: SessionData) => void;
   sessionId: string;
   effectiveSessionId: string;
   isLoading: boolean;
   error: string | null;
-  errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+  errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | 'STOP_ACCEPTING_ORDERS' | null;
   refresh: (forceRefresh?: boolean) => Promise<void>;
   items: TLineItemExpanded[];
   session: TCheckoutSessionExpanded | null | undefined;

package/src/checkout/core/crossSell.ts

@@ -2,28 +2,49 @@ import type { TCheckoutSessionExpanded, TPrice } from '@blocklet/payment-types';
 
 import api, { API } from '../../shared/api';
 import { recalculatePromotionIfNeeded } from './lineItems';
+import type { SessionData } from '../hooks/useCheckoutSession';
 
 export async function addCrossSellItem(
   sessionId: string,
   crossSellItemId: string,
   session: TCheckoutSessionExpanded | undefined | null,
   currencyId: string | null | undefined,
-  refresh: (force?: boolean) => Promise<void>
+  refresh: (force?: boolean) => Promise<void>,
+  sessionData?: SessionData | null,
+  setSessionData?: (data: SessionData) => void
 ): Promise<void> {
-  await api.put(API.CROSS_SELL(sessionId), { to: crossSellItemId });
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+  const { data } = await api.put(API.CROSS_SELL(sessionId), { to: crossSellItemId });
+  let finalSession = data;
+  if (data.discounts?.length) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: undefined });
+  } else {
+    await refresh(true);
+  }
 }
 
 export async function removeCrossSellItem(
   sessionId: string,
   session: TCheckoutSessionExpanded | undefined | null,
   currencyId: string | null | undefined,
-  refresh: (force?: boolean) => Promise<void>
+  refresh: (force?: boolean) => Promise<void>,
+  sessionData?: SessionData | null,
+  setSessionData?: (data: SessionData) => void
 ): Promise<void> {
-  await api.delete(API.CROSS_SELL(sessionId));
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+  const { data } = await api.delete(API.CROSS_SELL(sessionId));
+  let finalSession = data;
+  if (data.discounts?.length) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: undefined });
+  } else {
+    await refresh(true);
+  }
 }
 
 // Dedup concurrent fetchCrossSellItem calls (multiple useLineItems instances share one in-flight request)

package/src/checkout/core/customerForm.ts

@@ -41,12 +41,6 @@ export function buildFields(session: TCheckoutSessionExpanded | undefined | null
         required: true,
         group: 'address',
       },
-      {
-        name: 'billing_address.line2',
-        type: 'text',
-        required: false,
-        group: 'address',
-      },
       {
         name: 'billing_address.city',
         type: 'text',

package/src/checkout/core/lineItems.ts

@@ -3,17 +3,19 @@ import type { TCheckoutSessionExpanded, TLineItemExpanded, TPrice } from '@block
 import api, { API } from '../../shared/api';
 import { recalculatePromotion, hasAppliedDiscounts } from './promotion';
 import type { PriceWithCrossSell } from '../../types/checkout-augmented';
+import type { SessionData } from '../hooks/useCheckoutSession';
 
 export async function recalculatePromotionIfNeeded(
   session: TCheckoutSessionExpanded | undefined | null,
   sessionId: string,
   currencyId: string | null | undefined
-): Promise<void> {
-  if (!hasAppliedDiscounts(session)) return;
+): Promise<TCheckoutSessionExpanded | null> {
+  if (!hasAppliedDiscounts(session)) return null;
   try {
-    await recalculatePromotion(sessionId, currencyId);
+    return await recalculatePromotion(sessionId, currencyId);
   } catch {
     // Ignore recalculation error
+    return null;
   }
 }
 
@@ -23,15 +25,25 @@ export async function adjustQuantity(
   qty: number,
   currencyId: string | null | undefined,
   session: TCheckoutSessionExpanded | undefined | null,
-  refresh: (force?: boolean) => Promise<void>
+  refresh: (force?: boolean) => Promise<void>,
+  sessionData?: SessionData | null,
+  setSessionData?: (data: SessionData) => void
 ): Promise<void> {
-  await api.put(API.ADJUST_QUANTITY(sessionId), {
+  const { data } = await api.put(API.ADJUST_QUANTITY(sessionId), {
     itemId,
     quantity: qty,
     currency_id: currencyId,
   });
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+  let finalSession = data;
+  if (data.discounts?.length || hasAppliedDiscounts(session)) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: undefined });
+  } else {
+    await refresh(true);
+  }
 }
 
 export async function performUpsell(
@@ -40,7 +52,9 @@ export async function performUpsell(
   toId: string,
   session: TCheckoutSessionExpanded | undefined | null,
   currencyId: string | null | undefined,
-  refresh: (force?: boolean) => Promise<void>
+  refresh: (force?: boolean) => Promise<void>,
+  sessionData?: SessionData | null,
+  setSessionData?: (data: SessionData) => void
 ): Promise<void> {
   // Backend rejects upsell with multiple line items — auto-remove cross-sell first
   // Always try DELETE when multiple items exist (cross_sell flag may not be set)
@@ -51,9 +65,19 @@ export async function performUpsell(
       // No cross-sell to remove — will proceed and let upsell API decide
     }
   }
-  await api.put(API.UPSELL(sessionId), { from: fromId, to: toId });
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+  const { data } = await api.put(API.UPSELL(sessionId), { from: fromId, to: toId });
+
+  // Use PUT response directly; if discounts exist, recalculate and use that response
+  let finalSession = data;
+  if (data.discounts?.length || hasAppliedDiscounts(session)) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: undefined });
+  } else {
+    await refresh(true);
+  }
 }
 
 export async function performDownsell(
@@ -61,7 +85,9 @@ export async function performDownsell(
   priceId: string,
   session: TCheckoutSessionExpanded | undefined | null,
   currencyId: string | null | undefined,
-  refresh: (force?: boolean) => Promise<void>
+  refresh: (force?: boolean) => Promise<void>,
+  sessionData?: SessionData | null,
+  setSessionData?: (data: SessionData) => void
 ): Promise<void> {
   // Auto-remove cross-sell to keep interval consistency (cross-sell is interval-aware)
   if ((session?.line_items?.length || 0) > 1) {
@@ -71,9 +97,19 @@ export async function performDownsell(
       // No cross-sell to remove — will proceed and let downsell API decide
     }
   }
-  await api.put(API.DOWNSELL(sessionId), { from: priceId });
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+  const { data } = await api.put(API.DOWNSELL(sessionId), { from: priceId });
+
+  // Use PUT response directly; if discounts exist, recalculate and use that response
+  let finalSession = data;
+  if (data.discounts?.length || hasAppliedDiscounts(session)) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: undefined });
+  } else {
+    await refresh(true);
+  }
 }
 
 export async function changeDonationAmount(
@@ -82,16 +118,24 @@ export async function changeDonationAmount(
   amount: string,
   session: TCheckoutSessionExpanded | undefined | null,
   currencyId: string | null | undefined,
-  refresh: (force?: boolean) => Promise<void>
+  refresh: (force?: boolean) => Promise<void>,
+  sessionData?: SessionData | null,
+  setSessionData?: (data: SessionData) => void
 ): Promise<void> {
   const { data } = await api.put(API.CHANGE_AMOUNT(sessionId), {
     priceId,
     amount,
   });
+  let finalSession = data;
   if (data?.discounts?.length) {
-    await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: undefined });
+  } else {
+    await refresh(true);
   }
-  await refresh(true);
 }
 
 // Extract cross-sell price from items

package/src/checkout/core/paymentMethod.ts

@@ -36,11 +36,22 @@ export function getInitialCurrencyId(
   session: TCheckoutSessionExpanded | undefined | null,
   methods: TPaymentMethodExpanded[]
 ): string | null {
+  const availableCurrencyIds = new Set(
+    methods.flatMap((m) => (m.payment_currencies || []).map((c) => c.id)).filter(Boolean)
+  );
+  const isAvailable = (currencyId?: string | null) => !!currencyId && availableCurrencyIds.has(currencyId);
+
+  // Keep session currency stable when promotion is already applied.
+  // Auto-switching on refresh may trigger recalculate-promotion and remove discount.
+  if (session?.discounts?.length && isAvailable(session.currency_id)) {
+    return session.currency_id;
+  }
+
   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;
+      if (isAvailable(urlCurrency)) return urlCurrency;
     } catch {
       // Ignore
     }
@@ -49,28 +60,34 @@ export function getInitialCurrencyId(
     if (user && !hasDidWallet(user)) {
       const stripeMethod = methods.find((m) => m.type === 'stripe');
       const stripeCurrency = stripeMethod?.payment_currencies?.[0];
-      if (stripeCurrency) return stripeCurrency.id;
+      if (isAvailable(stripeCurrency?.id)) return stripeCurrency?.id as string;
     }
 
     try {
       const did = (session as CheckoutSessionRuntime | undefined)?.user?.did;
       const stored = localStorage.getItem(getCurrencyStorageKey(did));
-      if (stored) return stored;
+      if (isAvailable(stored)) return stored;
     } catch {
       // Ignore
     }
   }
-  return session?.currency_id || null;
+
+  if (isAvailable(session?.currency_id)) {
+    return session?.currency_id as string;
+  }
+
+  return methods[0]?.payment_currencies?.[0]?.id || null;
 }
 
 export function findMethodAndCurrency(
   methods: TPaymentMethodExpanded[],
   currencyId: string | null
 ): { method: TPaymentMethodExpanded | null; currency: TPaymentCurrency | null } {
+  // Return null when currencyId hasn't been initialized yet.
+  // Prevents premature fallback to the first currency (which may differ from session.currency_id),
+  // avoiding a wrong-currency recalculate-promotion call that removes fixed-amount discounts.
   if (!currencyId) {
-    const first = methods[0];
-    const firstCurrency = first?.payment_currencies?.[0] || null;
-    return { method: first || null, currency: firstCurrency };
+    return { method: null, currency: null };
   }
 
   for (const method of methods) {

package/src/checkout/core/pricing.ts

@@ -141,7 +141,6 @@ export function calculateAmounts(
   });
 
   const subtotalBN = new BN(result.total);
-  const subtotalFormatted = formatDynamicPrice(fromUnitToToken(subtotalBN, currency.decimal), hasDynamicPricing);
 
   // Calculate discount client-side from coupon data
   const discountBN = calculateCouponDiscount(items, currency, session, hasDynamicPricing, exchangeRate, trialing, false);
@@ -216,7 +215,7 @@ export function calculateAmounts(
 
   return {
     subtotal: `${displaySubtotalFormatted} ${currency.symbol}`,
-    paymentAmount: `${subtotalFormatted} ${currency.symbol}`,
+    paymentAmount: `${totalFormatted} ${currency.symbol}`,
     total: `${totalFormatted} ${currency.symbol}`,
     discount: discount ? `${discount} ${currency.symbol}` : null,
     tax,

package/src/checkout/core/promotion.ts

@@ -43,10 +43,14 @@ export async function removePromotionCode(sessionId: string): Promise<void> {
   await api.delete(API.REMOVE_PROMOTION(sessionId));
 }
 
-export async function recalculatePromotion(sessionId: string, currencyId: string | null | undefined): Promise<void> {
-  await api.post(API.RECALCULATE_PROMOTION_SESSION(sessionId), {
+export async function recalculatePromotion(
+  sessionId: string,
+  currencyId: string | null | undefined
+): Promise<TCheckoutSessionExpanded> {
+  const { data } = await api.post(API.RECALCULATE_PROMOTION_SESSION(sessionId), {
     currency_id: currencyId,
   });
+  return data;
 }
 
 export function isPromotionActive(session: TCheckoutSessionExpanded | undefined | null): boolean {

package/src/checkout/hooks/useBillingInterval.ts

@@ -22,14 +22,15 @@ export interface BillingIntervalData {
 export type UseBillingIntervalReturn = BillingIntervalData | null;
 
 export function useBillingInterval(): UseBillingIntervalReturn {
-  const { items, session, effectiveSessionId, refresh } = useSessionContext();
+  const { items, session, effectiveSessionId, refresh, sessionData, setSessionData } = useSessionContext();
   const { currency } = usePaymentMethodContext();
   const currencyId = currency?.id || null;
   const [switching, setSwitching] = useState(false);
+  const [pendingInterval, setPendingInterval] = useState<BillingIntervalType | null>(null);
 
   const upsell = useMemoizedFn(async (fromId: string, toId: string) => {
     try {
-      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err: unknown) {
       console.error('Failed to upsell:', getErrorMessage(err));
     }
@@ -37,7 +38,7 @@ export function useBillingInterval(): UseBillingIntervalReturn {
 
   const downsell = useMemoizedFn(async (priceId: string) => {
     try {
-      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh);
+      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err: unknown) {
       console.error('Failed to downsell:', getErrorMessage(err));
     }
@@ -48,13 +49,14 @@ export function useBillingInterval(): UseBillingIntervalReturn {
     if (!parsed) return null;
 
     return {
-      current: parsed.current,
+      current: pendingInterval || parsed.current,
       available: parsed.available,
       switching,
       switch: async (interval: BillingIntervalType) => {
         const target = parsed.available.find((a) => a.interval === interval);
         if (!target || switching) return;
 
+        setPendingInterval(interval);
         setSwitching(true);
         try {
           if (!parsed.firstItem.upsell_price_id && target.priceId) {
@@ -64,8 +66,9 @@ export function useBillingInterval(): UseBillingIntervalReturn {
           }
         } finally {
           setSwitching(false);
+          setPendingInterval(null);
         }
       },
     };
-  }, [items, effectiveSessionId, switching]); // eslint-disable-line react-hooks/exhaustive-deps
+  }, [items, effectiveSessionId, switching, pendingInterval]); // eslint-disable-line react-hooks/exhaustive-deps
 }

package/src/checkout/hooks/useCheckout.ts

@@ -28,6 +28,7 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
     error,
     errorCode,
     refresh,
+    setSessionData,
     sessionData,
     resolvedSessionId,
     vendorCount,
@@ -41,7 +42,7 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
   const effectiveSessionId = resolvedSessionId || sessionId;
 
   // 2. Payment method
-  const paymentMethodHook = usePaymentMethod(sessionData, effectiveSessionId, refresh);
+  const paymentMethodHook = usePaymentMethod(sessionData, effectiveSessionId, refresh, setSessionData);
 
   // 3. Pricing
   const pricingHook = usePricing(
@@ -50,7 +51,8 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
     paymentMethodHook.currency,
     paymentMethodHook.isStripe,
     refresh,
-    paymentMethodHook.current?.type || null
+    paymentMethodHook.current?.type || null,
+    paymentMethodHook.switching
   );
 
   // 4. Customer form
@@ -77,23 +79,29 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
   );
 
   // 7. Line items operations
-  const items = (session?.line_items || []) as TLineItemExpanded[];
+  const items = useMemo(() => (session?.line_items || []) as TLineItemExpanded[], [session?.line_items]);
   const currencyId = paymentMethodHook.currency?.id || null;
 
-  // Recalculate promotion when currency changes or on initial load
+  // Recalculate promotion when currency changes or on initial mount (if discounts exist).
+  // Uses refresh() (fresh GET) instead of POST response to avoid stale-closure overwrites
+  // when switch-currency and recalculate-promotion race. Matches V1 pattern.
   const prevCurrencyRef = useRef<string | null>(null);
   useEffect(() => {
     const currId = paymentMethodHook.currency?.id || null;
-    if (!currId || !session) return;
+    if (!currId || !session || session.status === 'complete') return;
     if (prevCurrencyRef.current === null || currId !== prevCurrencyRef.current) {
       prevCurrencyRef.current = currId;
-      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then(() => refresh(true));
+      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then((recalculated) => {
+        if (recalculated) {
+          refresh(true);
+        }
+      });
     }
   }, [paymentMethodHook.currency?.id, session?.id]); // eslint-disable-line react-hooks/exhaustive-deps
 
   const updateQuantity = useMemoizedFn(async (itemId: string, qty: number) => {
     try {
-      await adjustQuantity(effectiveSessionId, itemId, qty, currencyId, session, refresh);
+      await adjustQuantity(effectiveSessionId, itemId, qty, currencyId, session, refresh, sessionData, setSessionData);
     } catch (err: unknown) {
       console.error('Failed to update quantity:', getErrorMessage(err));
     }
@@ -101,7 +109,7 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
 
   const upsell = useMemoizedFn(async (fromId: string, toId: string) => {
     try {
-      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err: unknown) {
       console.error('Failed to upsell:', getErrorMessage(err));
     }
@@ -109,7 +117,7 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
 
   const downsell = useMemoizedFn(async (priceId: string) => {
     try {
-      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh);
+      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err: unknown) {
       console.error('Failed to downsell:', getErrorMessage(err));
     }
@@ -140,7 +148,7 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
   const addCrossSell = useMemoizedFn(async () => {
     if (!crossSellItem) return;
     try {
-      await addCrossSellItem(effectiveSessionId, crossSellItem.id, session, currencyId, refresh);
+      await addCrossSellItem(effectiveSessionId, crossSellItem.id, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err: unknown) {
       console.error('Failed to add cross-sell:', getErrorMessage(err));
     }
@@ -148,7 +156,7 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
 
   const removeCrossSell = useMemoizedFn(async () => {
     try {
-      await removeCrossSellItem(effectiveSessionId, session, currencyId, refresh);
+      await removeCrossSellItem(effectiveSessionId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err: unknown) {
       console.error('Failed to remove cross-sell:', getErrorMessage(err));
     }
@@ -179,7 +187,7 @@ export function useCheckout(sessionId: string): UseCheckoutReturn {
   const setDonationAmount = useMemoizedFn(async (priceId: string, amount: string) => {
     if (!isDonation) return;
     try {
-      await changeDonationAmount(effectiveSessionId, priceId, amount, session, currencyId, refresh);
+      await changeDonationAmount(effectiveSessionId, priceId, amount, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err: unknown) {
       console.error('Failed to change amount:', getErrorMessage(err));
     }

package/src/checkout/hooks/useCheckoutSession.ts

@@ -36,8 +36,8 @@ export interface UseCheckoutSessionReturn {
   // Loading
   isLoading: boolean;
   error: string | null;
-  /** Error code for structured error handling: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null */
-  errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+  /** Error code for structured error handling */
+  errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | 'STOP_ACCEPTING_ORDERS' | null;
   refresh: (forceRefresh?: boolean) => Promise<void>;
   /** Directly update session data (e.g. after completion polling returns fresh data) */
   setSessionData: (data: SessionData) => void;
@@ -151,6 +151,13 @@ export function useCheckoutSession(sessionId: string): UseCheckoutSessionReturn
         }
       }
 
+      // System-level order acceptance check (only block non-completed sessions)
+      if (data?.stopAcceptingOrders && cs?.status !== 'complete') {
+        setError('STOP_ACCEPTING_ORDERS');
+        setIsLoading(false);
+        return;
+      }
+
       setSessionData(data);
       setIsLoading(false);
     } catch (err: unknown) {
@@ -188,11 +195,13 @@ export function useCheckoutSession(sessionId: string): UseCheckoutSessionReturn
   const resolvedSessionId = resolvedIdRef.current || (isPaymentLink ? '' : sessionId);
 
   // Determine error code for structured handling
-  let errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null = null;
+  let errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | 'STOP_ACCEPTING_ORDERS' | null = null;
   if (error === 'SESSION_EXPIRED') {
     errorCode = 'SESSION_EXPIRED';
   } else if (error === 'EMPTY_LINE_ITEMS') {
     errorCode = 'EMPTY_LINE_ITEMS';
+  } else if (error === 'STOP_ACCEPTING_ORDERS') {
+    errorCode = 'STOP_ACCEPTING_ORDERS';
   }
 
   // Count vendor configs for post-payment polling

package/src/checkout/hooks/useCheckoutStatus.ts

@@ -3,7 +3,7 @@ import { useSessionContext } from '../context/SessionContext';
 export interface UseCheckoutStatusReturn {
   isLoading: boolean;
   error: string | null;
-  errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+  errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | 'STOP_ACCEPTING_ORDERS' | null;
   canSubmit: boolean;
   isCompleted: boolean;
   isDonation: boolean;