payment-kit 1.18.30 → 1.18.31

package/api/src/routes/checkout-sessions.ts

@@ -31,16 +31,15 @@ import {
   getStatementDescriptor,
   getSupportedPaymentCurrencies,
   getSupportedPaymentMethods,
-  isDonationCheckoutSession,
   isLineItemAligned,
-} from '../libs/session';
-import {
+  isDonationCheckoutSession,
+  createGroupSubscriptions,
   formatSubscriptionProduct,
-  getDaysUntilCancel,
-  getDaysUntilDue,
-  getSubscriptionCreateSetup,
-  getSubscriptionTrialSetup,
-} from '../libs/subscription';
+  getOneTimeLineItems,
+  getCheckoutSessionSubscriptionIds,
+  getSubscriptionLineItems,
+} from '../libs/session';
+import { getDaysUntilCancel, getDaysUntilDue, getSubscriptionTrialSetup } from '../libs/subscription';
 import {
   CHECKOUT_SESSION_TTL,
   formatAmountPrecisionLimit,
@@ -50,7 +49,6 @@ import {
   isUserInBlocklist,
 } from '../libs/util';
 import {
-  Invoice,
   PaymentBeneficiary,
   SetupIntent,
   Subscription,
@@ -59,6 +57,8 @@ import {
   type SubscriptionData,
   type TPriceExpanded,
   type TProductExpanded,
+  type TLineItemExpanded,
+  Invoice,
 } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
@@ -68,15 +68,24 @@ import { PaymentLink } from '../store/models/payment-link';
 import { PaymentMethod } from '../store/models/payment-method';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
-import { ensureStripePaymentIntent, ensureStripeSubscription } from '../integrations/stripe/resource';
+import {
+  ensureStripePaymentIntent,
+  ensureStripeSetupIntentForCheckoutSession,
+  ensureStripeSubscription,
+} from '../integrations/stripe/resource';
 import { handleStripePaymentSucceed } from '../integrations/stripe/handlers/payment-intent';
 import { paymentQueue } from '../queues/payment';
 import { invoiceQueue } from '../queues/invoice';
-import { ensureInvoiceForCheckout } from './connect/shared';
-import { isCreditSufficientForPayment, isDelegationSufficientForPayment } from '../libs/payment';
+import { ensureInvoiceForCheckout, ensureInvoicesForSubscriptions } from './connect/shared';
+import {
+  isCreditSufficientForPayment,
+  isDelegationSufficientForPayment,
+  SufficientForPaymentResult,
+} from '../libs/payment';
 import { handleStripeSubscriptionSucceed } from '../integrations/stripe/handlers/subscription';
 import { CHARGE_SUPPORTED_CHAIN_TYPES } from '../libs/constants';
 import { blocklet } from '../libs/auth';
+import { addSubscriptionJob } from '../queues/subscription';
 
 const router = Router();
 
@@ -376,6 +385,7 @@ export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = tr
       payment_intent_data: {},
       submit_type: 'pay',
       cross_sell_behavior: 'auto',
+      enable_subscription_grouping: false,
     },
     pick(payload, [
       'currency_id',
@@ -398,8 +408,15 @@ export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = tr
       'success_url',
       'client_reference_id',
       'after_expiration',
+      'enable_subscription_grouping',
     ])
   );
+
+  // TODO: need to support stake subscription
+  if (raw.enable_subscription_grouping === true && !raw.subscription_data?.no_stake) {
+    throw new Error('Subscription grouping is only supported for stake-free subscriptions');
+  }
+
   if (payload.include_free_trial && raw.subscription_data) {
     raw.subscription_data.trial_period_days = Number(raw.subscription_data.trial_period_days);
   }
@@ -441,12 +458,14 @@ export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = tr
   if (items.some((x) => !x.price.active)) {
     throw new Error('Invalid line items for checkout session, some price may have been archived');
   }
+  const enableSubscriptionGrouping = payload.enable_subscription_grouping;
   for (let i = 0; i < items.length; i++) {
     const result = isLineItemAligned(items, i);
     if (result.currency === false) {
       throw new Error('line_items should have same currency');
     }
-    if (result.recurring === false) {
+    // if subscription grouping is not enabled, we need to check the recurring
+    if (result.recurring === false && !enableSubscriptionGrouping) {
       throw new Error('line_items should have same recurring');
     }
   }
@@ -566,6 +585,118 @@ export async function getCrossSellItem(checkoutSession: CheckoutSession) {
   return { error: 'Cross sell not suitable' };
 }
 
+/**
+ * Process fast checkout for subscriptions with sufficient balance
+ */
+async function processSubscriptionFastCheckout({
+  checkoutSession,
+  customer,
+  subscriptions,
+  paymentMethod,
+  paymentCurrency,
+  paymentSettings,
+  lineItems,
+  trialEnd,
+  now,
+}: {
+  checkoutSession: CheckoutSession;
+  customer: Customer;
+  subscriptions: Subscription[];
+  paymentMethod: PaymentMethod;
+  paymentCurrency: PaymentCurrency;
+  paymentSettings: any;
+  lineItems: TLineItemExpanded[];
+  trialEnd: number;
+  now: number;
+}): Promise<{
+  success: boolean;
+  invoices?: Invoice[];
+  message?: string;
+}> {
+  try {
+    const primarySubscription = subscriptions.find((x) => x.metadata?.is_primary_subscription) || subscriptions[0];
+    const subscriptionAmounts = await Promise.all(
+      subscriptions.map(async (sub) => {
+        const subItems = await getSubscriptionLineItems(sub, lineItems, primarySubscription);
+        return getFastCheckoutAmount(subItems, 'subscription', paymentCurrency.id, trialEnd > now);
+      })
+    );
+    const totalAmount = subscriptionAmounts
+      .reduce((sum: BN, amt: string) => sum.add(new BN(amt)), new BN('0'))
+      .toString();
+
+    const delegationCheck = await isDelegationSufficientForPayment({
+      paymentMethod,
+      paymentCurrency,
+      userDid: customer.did,
+      amount: totalAmount,
+      delegatorAmounts: subscriptionAmounts,
+    });
+
+    if (!delegationCheck.sufficient) {
+      logger.warn('Fast checkout for subscription failed due to insufficient delegation or insufficient balance', {
+        checkoutSessionId: checkoutSession.id,
+        reason: delegationCheck.reason,
+      });
+
+      return {
+        success: false,
+        message: `Insufficient delegation or insufficient balance: ${delegationCheck.reason}`,
+      };
+    }
+
+    // All subscriptions have sufficient delegation, proceed with checkout
+    logger.info('All subscriptions have sufficient delegation for fast checkout', {
+      checkoutSessionId: checkoutSession.id,
+      subscriptionIds: subscriptions.map((s) => s.id),
+    });
+
+    // Update payment settings for all subscriptions
+    await Promise.all(subscriptions.map((sub) => sub.update({ payment_settings: paymentSettings })));
+
+    // Create invoices for all subscriptions
+    const { invoices } = await ensureInvoicesForSubscriptions({
+      checkoutSession,
+      customer,
+      subscriptions,
+    });
+
+    // Update invoice settings and push to queue
+    await Promise.all(
+      invoices.map(async (invoice) => {
+        if (invoice) {
+          await invoice.update({ auto_advance: true, payment_settings: paymentSettings });
+          invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
+        }
+      })
+    );
+
+    // Add subscription cycle jobs
+    await Promise.all(subscriptions.map((sub) => addSubscriptionJob(sub, 'cycle', false, sub.trial_end)));
+
+    logger.info('Created and queued invoices for fast checkout with subscriptions', {
+      checkoutSessionId: checkoutSession.id,
+      subscriptionIds: subscriptions.map((s) => s.id),
+      invoiceIds: invoices.map((inv) => inv.id),
+    });
+
+    return {
+      success: true,
+      invoices,
+    };
+  } catch (error) {
+    logger.error('Error processing subscription fast checkout', {
+      error,
+      checkoutSessionId: checkoutSession.id,
+    });
+
+    return {
+      success: false,
+      message: error.message,
+    };
+  }
+}
+
 // create checkout session
 router.post('/', auth, async (req, res) => {
   const raw: Partial<CheckoutSession> = await formatCheckoutSession(req.body);
@@ -609,6 +740,11 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
     raw.currency_id = link.currency_id || req.currency.id;
     raw.payment_link_id = link.id;
 
+    // Inherit multi-subscription settings from payment link
+    if (typeof link.enable_subscription_grouping === 'boolean') {
+      raw.enable_subscription_grouping = link.enable_subscription_grouping;
+    }
+
     // Settings priority: PaymentLink.subscription_data > req.query > environments
     const protectedSettings: Partial<SubscriptionData> = {};
     if (link.subscription_data?.min_stake_amount) {
@@ -776,14 +912,31 @@ router.get('/retrieve/:id', user, async (req, res) => {
     return;
   }
 
+  let subscriptions: Subscription[] = [];
+  if (['subscription', 'setup'].includes(doc.mode)) {
+    const subscriptionIds = getCheckoutSessionSubscriptionIds(doc);
+    if (doc.success_subscription_count === subscriptionIds.length && doc.status === 'incomplete') {
+      await doc.update({
+        status: 'complete',
+        payment_status: 'paid',
+      });
+    }
+    subscriptions = await Subscription.findAll({
+      where: { id: subscriptionIds },
+      attributes: ['id', 'description', 'status', 'current_period_start', 'current_period_end', 'latest_invoice_id'],
+    });
+  }
+
   // @ts-ignore
   doc.line_items = await Price.expand(doc.line_items, { upsell: true });
 
   // check payment intent
   const paymentIntent = doc.payment_intent_id ? await PaymentIntent.findByPk(doc.payment_intent_id) : null;
-
   res.json({
-    checkoutSession: doc.toJSON(),
+    checkoutSession: {
+      ...doc.toJSON(),
+      subscriptions,
+    },
     paymentMethods: await getPaymentMethods(doc),
     paymentLink: doc.payment_link_id ? await PaymentLink.findByPk(doc.payment_link_id) : null,
     paymentIntent,
@@ -1003,134 +1156,42 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
 
     // subscription processing
     let subscription: Subscription | null = null;
-    if (checkoutSession.mode === 'subscription' || checkoutSession.mode === 'setup') {
-      if (checkoutSession.subscription_id) {
-        subscription = await Subscription.findByPk(checkoutSession.subscription_id);
-      }
-      if (subscription) {
-        if (subscription.status !== 'incomplete') {
-          return res
-            .status(403)
-            .json({ code: 'SUBSCRIPTION_INVALID', error: 'Checkout session subscription status unexpected' });
-        }
-        const setup = getSubscriptionCreateSetup(lineItems, paymentCurrency.id, trialInDays, trialEnd);
-        subscription = await subscription.update({
-          currency_id: paymentCurrency.id,
-          customer_id: customer.id,
-          default_payment_method_id: paymentMethod.id,
-          current_period_start: setup.period.start,
-          current_period_end: setup.period.end,
-          billing_cycle_anchor: checkoutSession.subscription_data?.billing_cycle_anchor || setup.cycle.anchor,
-          trial_end: setup.trial.end,
-          trial_start: setup.trial.start,
-          pending_invoice_item_interval: setup.recurring,
-          pending_setup_intent: setupIntent?.id,
-        });
-        logger.info('subscription updated on checkout session resubmit', {
-          session: checkoutSession.id,
-          subscription: subscription.id,
-        });
+    let subscriptions: Subscription[] = [];
 
-        // rebuild subscription items
-        await SubscriptionItem.destroy({ where: { subscription_id: subscription.id } });
-        const items = await Promise.all(
-          lineItems
-            .filter((x) => x.price.type === 'recurring')
-            .map((x) =>
-              SubscriptionItem.create({
-                livemode: !!checkoutSession.livemode,
-                // @ts-ignore
-                subscription_id: subscription.id,
-                price_id: x.upsell_price_id || x.price_id,
-                quantity: x.quantity,
-                metadata: checkoutSession.metadata as any,
-              })
-            )
-        );
-        logger.info('subscription items rebuilt on checkout session resubmit', {
-          session: checkoutSession.id,
-          items: items.map((x) => x.id),
-        });
-        const invoice = await Invoice.findByPk(subscription?.latest_invoice_id);
-        if (invoice && invoice.customer_id !== customer.id) {
-          invoice.update({
-            customer_id: customer.id,
-          });
-        }
-      } else {
-        const recoveredFromId = checkoutSession.subscription_data?.recovered_from || '';
-        const recoveredFrom = recoveredFromId ? await Subscription.findByPk(recoveredFromId) : null;
-
-        // FIXME: @wangshijun respect all checkoutSession.subscription_data fields
-        const setup = getSubscriptionCreateSetup(lineItems, paymentCurrency.id, trialInDays, trialEnd);
-        subscription = await Subscription.create({
-          livemode: !!checkoutSession.livemode,
-          currency_id: paymentCurrency.id,
-          customer_id: customer.id,
-          status: 'incomplete',
-          current_period_start: setup.period.start,
-          current_period_end: setup.period.end,
-          // FIXME: billing_cycle_anchor implementation is not aligned with stripe
-          billing_cycle_anchor: checkoutSession.subscription_data?.billing_cycle_anchor || setup.cycle.anchor,
-          start_date: dayjs().unix(),
-          trial_end: setup.trial.end,
-          trial_start: setup.trial.start,
-          trial_settings: {
-            end_behavior: {
-              missing_payment_method: 'create_invoice',
-            },
-          },
-          billing_thresholds: {
-            amount_gte: getBillingThreshold(checkoutSession.subscription_data as any),
-            stake_gte: getMinStakeAmount(checkoutSession.subscription_data as any),
-            reset_billing_cycle_anchor: false,
-          },
-          pending_invoice_item_interval: setup.recurring,
-          pending_setup_intent: setupIntent?.id,
-          default_payment_method_id: paymentMethod.id,
-          cancel_at_period_end: false,
-          collection_method: 'charge_automatically',
-          description:
-            checkoutSession.subscription_data?.description ||
-            formatSubscriptionProduct(lineItems.filter((x) => x.price.type === 'recurring')),
-          proration_behavior: checkoutSession.subscription_data?.proration_behavior || 'none',
-          payment_behavior: 'default_incomplete',
-          days_until_due: checkoutSession.subscription_data?.days_until_due ?? checkoutSession.metadata?.days_until_due,
-          days_until_cancel:
-            checkoutSession.subscription_data?.days_until_cancel ?? checkoutSession.metadata?.days_until_cancel,
-          recovered_from: recoveredFrom?.id,
-          metadata: omit(checkoutSession.metadata || {}, ['days_until_due', 'days_until_cancel']),
-          service_actions: checkoutSession.subscription_data?.service_actions || [],
-        });
+    if (checkoutSession.mode === 'subscription' || checkoutSession.mode === 'setup') {
+      const {
+        subscriptions: groupSubscriptions,
+        subscriptionGroups,
+        primarySubscription,
+      } = await createGroupSubscriptions({
+        checkoutSession,
+        lineItems,
+        customer,
+        paymentSettings: {
+          method: paymentMethod,
+          currency: paymentCurrency,
+        },
+        setupIntent,
+        trialConfig: {
+          trialInDays,
+          trialEnd,
+        },
+      });
 
-        logger.info('subscription created on checkout session submit', {
-          session: checkoutSession.id,
-          subscription: subscription.id,
-        });
+      subscription = primarySubscription;
+      subscriptions = groupSubscriptions;
 
-        // create subscription items
-        const items = await Promise.all(
-          lineItems
-            .filter((x) => x.price.type === 'recurring')
-            .map((x) =>
-              SubscriptionItem.create({
-                livemode: !!checkoutSession.livemode,
-                // @ts-ignore
-                subscription_id: subscription.id,
-                price_id: x.upsell_price_id || x.price_id,
-                quantity: x.quantity,
-                metadata: checkoutSession.metadata as any,
-              })
-            )
-        );
-        logger.info('subscription items created on checkout session submit', {
-          session: checkoutSession.id,
-          items: items.map((x) => x.id),
-        });
+      await checkoutSession.update({
+        subscription_id: subscription ? (subscription as any).id : null,
+        subscription_groups: subscriptionGroups,
+      });
 
-        // persist subscription id
-        await checkoutSession.update({ subscription_id: subscription.id });
-      }
+      logger.info('Checkout session updated with subscription information', {
+        session: checkoutSession.id,
+        groups: subscriptionGroups,
+        primarySubscription: subscription ? (subscription as any).id : null,
+        enableSubscriptionGrouping: checkoutSession.enable_subscription_grouping,
+      });
     }
 
     const fastCheckoutAmount = getFastCheckoutAmount(
@@ -1142,7 +1203,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
     const paymentSettings = {
       payment_method_types: checkoutSession.payment_method_types,
       payment_method_options: {
-        arcblock: { payer: customer.did },
+        [paymentMethod.type]: { payer: customer.did },
       },
     };
 
@@ -1153,16 +1214,18 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       customer,
       amount: fastCheckoutAmount,
     });
-    // if we can complete purchase without any wallet interaction
-    const delegation = await isDelegationSufficientForPayment({
-      paymentMethod,
-      paymentCurrency,
-      userDid: customer.did,
-      amount: fastCheckoutAmount,
-    });
 
-    const canFastPay = canPayWithDelegation(paymentIntent?.beneficiaries || []);
-    if (checkoutSession.mode === 'payment' && paymentIntent && canFastPay) {
+    const isPayment = checkoutSession.mode === 'payment';
+    let canFastPay = isPayment && canPayWithDelegation(paymentIntent?.beneficiaries || []);
+    let delegation: SufficientForPaymentResult | null = null;
+    if (isPayment && paymentIntent && canFastPay) {
+      // if we can complete purchase without any wallet interaction
+      delegation = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: customer.did,
+        amount: fastCheckoutAmount,
+      });
       if (balance.sufficient) {
         logger.info(`CheckoutSession ${checkoutSession.id} will pay from balance ${paymentIntent?.id}`);
       }
@@ -1182,6 +1245,34 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
           });
         }
       }
+    } else if (
+      paymentMethod.type === 'arcblock' &&
+      checkoutSession.mode === 'subscription' &&
+      checkoutSession.subscription_data?.no_stake
+    ) {
+      // if we can complete purchase without any wallet interaction
+      const result = await processSubscriptionFastCheckout({
+        checkoutSession,
+        customer,
+        subscriptions,
+        paymentMethod,
+        paymentCurrency,
+        paymentSettings,
+        lineItems,
+        trialEnd,
+        now,
+      });
+
+      if (!result.success) {
+        logger.warn(`Fast checkout processing failed: ${result.message}`, {
+          checkoutSessionId: checkoutSession.id,
+        });
+      } else {
+        delegation = {
+          sufficient: true,
+        };
+        canFastPay = true;
+      }
     }
 
     let stripeContext: any = null;
@@ -1206,46 +1297,91 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
           intent_type: 'payment_intent',
         };
       }
-
-      if (subscription) {
-        const stripeSubscription = await ensureStripeSubscription(
-          subscription,
-          paymentMethod,
-          paymentCurrency,
-          lineItems,
-          trialInDays,
-          trialEnd
+      if (subscriptions.length > 0) {
+        const primarySubscription = (subscriptions.find((x) => x.metadata.is_primary_subscription) ||
+          subscriptions[0]) as Subscription;
+        if (!stripeContext) {
+          stripeContext = {
+            type: 'subscription',
+            stripe_subscriptions: '',
+          };
+        }
+        stripeContext.stripe_subscriptions = '';
+        await Promise.all(
+          subscriptions.map(async (sub) => {
+            const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: sub.id } });
+            let stripeItems = lineItems.filter((x) =>
+              subscriptionItems.some((y) => y.price_id === x.price_id || y.price_id === x.upsell_price_id)
+            );
+            if (sub.id === primarySubscription.id) {
+              stripeItems = [...stripeItems, ...getOneTimeLineItems(lineItems)];
+            }
+            const stripeSubscription = await ensureStripeSubscription(
+              sub,
+              paymentMethod,
+              paymentCurrency,
+              stripeItems,
+              trialInDays,
+              trialEnd
+            );
+            if (stripeSubscription) {
+              await sub.update({
+                payment_details: {
+                  stripe: {
+                    customer_id: stripeSubscription.customer,
+                    subscription_id: stripeSubscription.id,
+                    setup_intent_id: stripeSubscription.pending_setup_intent?.id,
+                  },
+                },
+              });
+            }
+            logger.info('ensureStripeSubscription', {
+              subscriptionId: sub.id,
+              stripeSubscriptionId: stripeSubscription?.id,
+              checkoutSessionId: checkoutSession.id,
+            });
+            if (stripeSubscription && sub?.payment_details?.stripe?.subscription_id === stripeSubscription.id) {
+              if (['active', 'trialing'].includes(stripeSubscription.status) && sub.status === 'incomplete') {
+                await handleStripeSubscriptionSucceed(sub, stripeSubscription.status);
+              }
+            }
+
+            stripeContext.stripe_subscriptions += `${stripeSubscription.id},`;
+            if (sub.id === primarySubscription.id) {
+              stripeContext = {
+                type: 'subscription',
+                id: stripeSubscription.id,
+                // @ts-ignore
+                client_secret:
+                  stripeSubscription.latest_invoice?.payment_intent?.client_secret ||
+                  stripeSubscription.pending_setup_intent?.client_secret,
+                intent_type: stripeSubscription.latest_invoice?.payment_intent ? 'payment_intent' : 'setup_intent',
+                status: stripeSubscription.status,
+              };
+            }
+            return {
+              stripeSubscription,
+              subscription: sub,
+            };
+          })
         );
-        if (stripeSubscription) {
-          await subscription.update({
-            payment_details: {
-              stripe: {
-                customer_id: stripeSubscription.customer,
-                subscription_id: stripeSubscription.id,
-                setup_intent_id: stripeSubscription.pending_setup_intent?.id,
-              },
-            },
+        if (subscriptions.length > 1) {
+          stripeContext.has_multiple_subscriptions = true;
+          const stripeSetupIntent = await ensureStripeSetupIntentForCheckoutSession(checkoutSession, paymentMethod, {
+            checkoutSessionId: checkoutSession.id,
+            subscription_groups: subscriptions.map((x) => x.id).join(','),
           });
-        }
-        logger.info('ensureStripeSubscription', {
-          subscriptionId: subscription.id,
-          stripeSubscriptionId: stripeSubscription?.id,
-        });
-        if (stripeSubscription && subscription?.payment_details?.stripe?.subscription_id === stripeSubscription.id) {
-          if (['active', 'trialing'].includes(stripeSubscription.status) && subscription.status === 'incomplete') {
-            await handleStripeSubscriptionSucceed(subscription, stripeSubscription.status);
+          if (stripeSetupIntent) {
+            stripeContext = {
+              type: 'subscription',
+              id: stripeSetupIntent.id,
+              // @ts-ignore
+              client_secret: stripeSetupIntent.client_secret,
+              intent_type: 'setup_intent',
+              status: stripeSetupIntent.status,
+            };
           }
         }
-        stripeContext = {
-          type: 'subscription',
-          id: stripeSubscription.id,
-          // @ts-ignore
-          client_secret:
-            stripeSubscription.latest_invoice?.payment_intent?.client_secret ||
-            stripeSubscription.pending_setup_intent?.client_secret,
-          intent_type: stripeSubscription.latest_invoice?.payment_intent ? 'payment_intent' : 'setup_intent',
-          status: stripeSubscription.status,
-        };
       }
     }
 
@@ -1262,10 +1398,11 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       setupIntent,
       stripeContext,
       subscription,
+      subscriptions,
       checkoutSession,
       customer,
-      delegation: checkoutSession.mode === 'payment' && canFastPay ? delegation : null,
-      balance: checkoutSession.mode === 'payment' && canFastPay ? balance : null,
+      delegation: canFastPay ? delegation : null,
+      balance: canFastPay ? balance : null,
     });
   } catch (err) {
     logger.error('Error submitting checkout session', {