@blocklet/payment-react-headless 1.26.0 → 1.26.2

package/src/checkout/context/SessionContext.ts

@@ -4,6 +4,8 @@ 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;

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/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/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(
@@ -77,23 +78,27 @@ 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 — use response directly (no extra GET)
   const prevCurrencyRef = useRef<string | null>(null);
   useEffect(() => {
     const currId = paymentMethodHook.currency?.id || null;
     if (!currId || !session) 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 && sessionData) {
+          setSessionData({ ...sessionData, checkoutSession: recalculated, quotes: undefined });
+        }
+      });
     }
   }, [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 +106,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 +114,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 +145,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 +153,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 +184,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/useCrossSell.ts

@@ -17,7 +17,7 @@ export interface UseCrossSellReturn {
 }
 
 export function useCrossSell(): UseCrossSellReturn {
-  const { items, session, effectiveSessionId, refresh } = useSessionContext();
+  const { items, session, effectiveSessionId, refresh, sessionData, setSessionData } = useSessionContext();
   const { currency } = usePaymentMethodContext();
   const currencyId = currency?.id || null;
 
@@ -61,7 +61,15 @@ export function useCrossSell(): UseCrossSellReturn {
     const crossSellItemPrice = getCrossSellItem(items);
     if (!crossSellItemPrice) return;
     try {
-      await addCrossSellItem(effectiveSessionId, crossSellItemPrice.id, session, currencyId, refresh);
+      await addCrossSellItem(
+        effectiveSessionId,
+        crossSellItemPrice.id,
+        session,
+        currencyId,
+        refresh,
+        sessionData,
+        setSessionData
+      );
     } catch (err: unknown) {
       console.error('Failed to add cross-sell:', getErrorMessage(err));
     }
@@ -70,7 +78,7 @@ export function useCrossSell(): UseCrossSellReturn {
   const remove = useMemoizedFn(async () => {
     if (session?.status === 'complete') return;
     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));
     }

package/src/checkout/hooks/useLineItems.ts

@@ -39,14 +39,21 @@ export interface UseLineItemsReturn {
 }
 
 export function useLineItems(): UseLineItemsReturn {
-  const { items, session, effectiveSessionId, isDonation, refresh } = useSessionContext();
+  const { items, session, effectiveSessionId, isDonation, refresh, sessionData, setSessionData } = useSessionContext();
   const { currency } = usePaymentMethodContext();
   const currencyId = currency?.id || null;
 
   // Default quantity from URL params: ?qty=5 or ?qty_price_xxx=10 (matching original product-item.tsx)
   const defaultQtyApplied = useRef(false);
   useEffect(() => {
-    if (defaultQtyApplied.current || !effectiveSessionId || !items.length || !currencyId || session?.status === 'complete') return;
+    if (
+      defaultQtyApplied.current ||
+      !effectiveSessionId ||
+      !items.length ||
+      !currencyId ||
+      session?.status === 'complete'
+    )
+      return;
     try {
       const params = new URLSearchParams(window.location.search);
       for (const item of items) {
@@ -55,7 +62,16 @@ export function useLineItems(): UseLineItemsReturn {
           const qty = Math.max(1, parseInt(qtyStr, 10));
           if (Number.isFinite(qty) && qty !== item.quantity) {
             defaultQtyApplied.current = true;
-            adjustQuantity(effectiveSessionId, item.price_id, qty, currencyId, session, refresh);
+            adjustQuantity(
+              effectiveSessionId,
+              item.price_id,
+              qty,
+              currencyId,
+              session,
+              refresh,
+              sessionData,
+              setSessionData
+            );
             break; // only apply to the first matching item for ?qty
           }
         }
@@ -68,7 +84,7 @@ export function useLineItems(): UseLineItemsReturn {
   const updateQuantity = useMemoizedFn(async (itemId: string, qty: number) => {
     if (session?.status === 'complete') return;
     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));
     }
@@ -76,12 +92,12 @@ export function useLineItems(): UseLineItemsReturn {
 
   const upsell = useMemoizedFn(async (fromId: string, toId: string) => {
     if (session?.status === 'complete') return;
-    await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+    await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh, sessionData, setSessionData);
   });
 
   const downsell = useMemoizedFn(async (priceId: string) => {
     if (session?.status === 'complete') return;
-    await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh);
+    await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh, sessionData, setSessionData);
   });
 
   // Cross-sell item detection (must be before addCrossSell so it can reference crossSellItem)
@@ -124,7 +140,15 @@ export function useLineItems(): UseLineItemsReturn {
     if (session?.status === 'complete') return;
     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));
     }
@@ -133,7 +157,7 @@ export function useLineItems(): UseLineItemsReturn {
   const removeCrossSell = useMemoizedFn(async () => {
     if (session?.status === 'complete') return;
     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));
     }
@@ -143,7 +167,16 @@ export function useLineItems(): UseLineItemsReturn {
     if (session?.status === 'complete') return;
     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/usePaymentMethod.ts

@@ -13,6 +13,7 @@ import {
   findMethodAndCurrency,
   buildPaymentTypes,
 } from '../core/paymentMethod';
+import { recalculatePromotionIfNeeded } from '../core/lineItems';
 import type { SessionData } from './useCheckoutSession';
 
 export interface UsePaymentMethodReturn {
@@ -42,9 +43,10 @@ export interface UsePaymentMethodReturn {
 export function usePaymentMethod(
   sessionData: SessionData | null,
   sessionId: string,
-  refreshSession: (force?: boolean) => Promise<void>
+  refreshSession: (force?: boolean) => Promise<void>,
+  setSessionData?: (data: SessionData) => void
 ): UsePaymentMethodReturn {
-  const methods = sessionData?.paymentMethods || [];
+  const methods = useMemo(() => sessionData?.paymentMethods || [], [sessionData?.paymentMethods]);
   const session = sessionData?.checkoutSession;
 
   const [currencyId, setCurrencyId] = useState<string | null>(() => getInitialCurrencyId(session, methods));
@@ -88,7 +90,7 @@ export function usePaymentMethod(
 
     setSwitching(true);
     try {
-      await api.put(API.SWITCH_CURRENCY(sessionId), {
+      const { data } = await api.put(API.SWITCH_CURRENCY(sessionId), {
         currency_id: newCurrencyId,
         payment_method_id: method.id,
       });
@@ -105,8 +107,18 @@ export function usePaymentMethod(
         // Ignore
       }
 
-      // Refresh session to get updated data (backend clears quote on currency switch)
-      await refreshSession(true);
+      // Use PUT response directly; if discounts exist, recalculate within switching state
+      let finalSession = data;
+      if (data.discounts?.length) {
+        const recalculated = await recalculatePromotionIfNeeded(session, sessionId, newCurrencyId);
+        if (recalculated) finalSession = recalculated;
+      }
+      // Clear quotes — they are currency-specific and stale after switch
+      if (sessionData && setSessionData) {
+        setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: undefined });
+      } else {
+        await refreshSession(true);
+      }
     } catch (err: unknown) {
       console.error('Failed to switch currency:', getErrorMessage(err));
       // Fallback: align with backend currency to resolve currencyMismatch

package/src/checkout/hooks/useUpsell.ts

@@ -11,13 +11,13 @@ export interface UseUpsellReturn {
 }
 
 export function useUpsell(): UseUpsellReturn {
-  const { session, effectiveSessionId, refresh } = useSessionContext();
+  const { session, effectiveSessionId, refresh, sessionData, setSessionData } = useSessionContext();
   const { currency } = usePaymentMethodContext();
   const currencyId = currency?.id || 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));
     }
@@ -25,7 +25,7 @@ export function useUpsell(): UseUpsellReturn {
 
   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));
     }