payment-kit 1.24.3 → 1.25.0

package/api/src/queues/subscription.ts

@@ -6,6 +6,7 @@ import { createEvent } from '../libs/audit';
 import { ensurePassportRevoked } from '../integrations/blocklet/passport';
 import { batchHandleStripeSubscriptions } from '../integrations/stripe/resource';
 import { wallet } from '../libs/auth';
+import { getExchangeRateService } from '../libs/exchange-rate';
 import dayjs from '../libs/dayjs';
 import { events } from '../libs/event';
 import { getLock } from '../libs/lock';
@@ -13,6 +14,7 @@ import logger from '../libs/logger';
 import { getGasPayerExtra, isDelegationSufficientForPayment } from '../libs/payment';
 import createQueue from '../libs/queue';
 import { getStatementDescriptor } from '../libs/session';
+import { NonRetryableError } from '../libs/error';
 import {
   checkRemainingStake,
   checkUsageReportEmpty,
@@ -30,9 +32,11 @@ import {
 } from '../libs/subscription';
 import { resetPeriodGrantCounter } from '../libs/credit-schedule';
 import { ensureInvoiceAndItems, migrateSubscriptionPaymentMethodInvoice } from '../libs/invoice';
+import { getQuoteService } from '../libs/quote-service';
+import { isRateBelowMinAcceptableRate } from '../libs/slippage';
 import { PaymentCurrency, PaymentIntent, PaymentMethod, Refund, SetupIntent, UsageRecord } from '../store/models';
 import { Customer } from '../store/models/customer';
-import { Invoice } from '../store/models/invoice';
+import { Invoice, nextInvoiceId } from '../store/models/invoice';
 import { Price } from '../store/models/price';
 import { Subscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
@@ -40,6 +44,8 @@ import { getValidDiscountsForSubscriptionBilling } from '../libs/discount/coupon
 import { invoiceQueue } from './invoice';
 import { SubscriptionWillCanceledSchedule } from '../crons/subscription-will-canceled';
 import { applySubscriptionDiscount } from '../libs/discount/discount';
+import type { ChainType, TLineItemExpanded } from '../store/models';
+import { getExchangeRateSymbol } from '../libs/exchange-rate/token-address-mapping';
 
 type SubscriptionJob = {
   subscriptionId: string;
@@ -48,6 +54,105 @@ type SubscriptionJob = {
 
 const EXPECTED_SUBSCRIPTION_STATUS = ['trialing', 'active', 'paused', 'past_due'];
 
+async function attachQuotesForInvoice(
+  lineItems: TLineItemExpanded[],
+  currencyId: string,
+  invoiceId: string,
+  slippageConfig?: { percent?: number; min_acceptable_rate?: string }
+): Promise<{
+  lineItems: TLineItemExpanded[];
+  quotes: any[];
+  slippageCheck?: { belowThreshold: boolean; currentRate?: string; minAcceptableRate?: string };
+}> {
+  // Filter dynamic items, excluding items with zero or negative quantity
+  // This matches the logic in invoice-quote.ts:generateQuotesForInvoiceItems
+  // to ensure quote creation is consistent with actual payment amount
+  const dynamicItems = lineItems.filter((item) => {
+    const price = (item as any)?.upsell_price || (item as any)?.price;
+    if (price?.pricing_type !== 'dynamic') {
+      return false;
+    }
+    // Skip items with zero or negative quantity (no usage, no payment needed)
+    if (item.quantity <= 0) {
+      return false;
+    }
+    return true;
+  });
+  if (!dynamicItems.length) {
+    return { lineItems, quotes: [] };
+  }
+
+  const currency = (await PaymentCurrency.findByPk(currencyId, {
+    include: [{ model: PaymentMethod, as: 'payment_method' }],
+  })) as PaymentCurrency & { payment_method: PaymentMethod };
+  if (!currency) {
+    throw new NonRetryableError('CURRENCY_NOT_FOUND', `Currency ${currencyId} not found`);
+  }
+
+  if (currency.payment_method?.type === 'stripe') {
+    return { lineItems, quotes: [] };
+  }
+
+  const exchangeRateService = getExchangeRateService();
+  const quoteService = getQuoteService();
+  // For ArcBlock payment method, always use ABT for exchange rate
+  const rateSymbol = getExchangeRateSymbol(currency.symbol, currency.payment_method?.type as ChainType);
+  const rateResult = await exchangeRateService.getRate(rateSymbol);
+
+  const rateBelowSlippage = isRateBelowMinAcceptableRate(rateResult.rate, slippageConfig?.min_acceptable_rate);
+
+  const quoteResults = await Promise.all(
+    dynamicItems.map(async (item) => {
+      const targetPrice: any = (item as any).upsell_price || (item as any).price;
+      const quoteResponse = await quoteService.createQuoteWithRate({
+        price_id: targetPrice.id,
+        invoice_id: invoiceId,
+        target_currency_id: currencyId,
+        quantity: item.quantity,
+        rateResult,
+        slippage_percent: slippageConfig?.percent,
+        min_acceptable_rate: undefined,
+      });
+      return { item, quoteResponse };
+    })
+  );
+
+  const quoteMap = new Map<string, (typeof quoteResults)[number]>();
+  quoteResults.forEach((result) => {
+    const targetPrice: any = (result.item as any).upsell_price || (result.item as any).price;
+    quoteMap.set(targetPrice.id, result);
+  });
+
+  const enriched = lineItems.map((item) => {
+    const targetPrice: any = (item as any).upsell_price || (item as any).price;
+    const hit = quoteMap.get(targetPrice?.id);
+    if (!hit) {
+      return item;
+    }
+    const { quoteResponse } = hit;
+    return {
+      ...item,
+      quote_id: quoteResponse.quote.id,
+      quoted_amount: quoteResponse.computed_unit_amount,
+      expires_at: quoteResponse.expires_at,
+      exchange_rate: quoteResponse.quote.exchange_rate,
+      rate_provider_name: quoteResponse.quote.rate_provider_name,
+      rate_provider_id: quoteResponse.quote.rate_provider_id,
+      custom_amount: quoteResponse.computed_unit_amount,
+    } as any;
+  });
+
+  return {
+    lineItems: enriched,
+    quotes: quoteResults.map((x) => x.quoteResponse.quote),
+    slippageCheck: {
+      belowThreshold: rateBelowSlippage,
+      currentRate: rateResult.rate,
+      minAcceptableRate: slippageConfig?.min_acceptable_rate,
+    },
+  };
+}
+
 const doHandleSubscriptionInvoice = async ({
   subscription,
   filter,
@@ -194,6 +299,21 @@ const doHandleSubscriptionInvoice = async ({
     return null;
   }
 
+  const invoiceId = nextInvoiceId();
+  // Get slippage config from subscription
+  const slippageConfig = subscription.slippage_config as { percent?: number; min_acceptable_rate?: string } | undefined;
+  const {
+    lineItems: itemsWithQuotes,
+    quotes,
+    slippageCheck,
+  } = await attachQuotesForInvoice(
+    expandedItems as TLineItemExpanded[],
+    subscription.currency_id,
+    invoiceId,
+    slippageConfig
+  );
+  expandedItems = itemsWithQuotes as any[];
+
   // Get valid discounts for this subscription billing period
   const { validDiscounts, expiredDiscounts } = await getValidDiscountsForSubscriptionBilling({
     subscriptionId: subscription.id,
@@ -279,6 +399,9 @@ const doHandleSubscriptionInvoice = async ({
     });
   }
 
+  const shouldMarkOverdue = slippageCheck?.belowThreshold === true;
+  const invoiceStatus = shouldMarkOverdue && status === 'open' ? 'uncollectible' : status;
+
   const { invoice } = await ensureInvoiceAndItems({
     customer,
     currency,
@@ -287,15 +410,17 @@ const doHandleSubscriptionInvoice = async ({
     metered: true,
     lineItems: enhancedLineItems,
     props: {
+      id: invoiceId,
       livemode: subscription.livemode,
       description: `Subscription ${reason}`,
       statement_descriptor: getStatementDescriptor(expandedItems),
       period_start: start,
       period_end: end,
       auto_advance: true,
-      status,
+      status: invoiceStatus,
       billing_reason: `subscription_${reason}`,
       currency_id: subscription.currency_id,
+      quote_id: quotes[0]?.id,
       // Set correct subtotal (original amount) and total (after discount)
       subtotal: baseAmount.total,
       total: safeFinalTotal,
@@ -306,10 +431,83 @@ const doHandleSubscriptionInvoice = async ({
       total_discount_amounts: discountBreakdownForInvoice,
       metadata: {
         ...metadata,
+        ...(slippageCheck
+          ? {
+              slippage: {
+                below_threshold: slippageCheck.belowThreshold,
+                min_acceptable_rate: slippageCheck.minAcceptableRate,
+                rate_at_invoice: slippageCheck.currentRate,
+              },
+            }
+          : {}),
+        quote_ids: quotes.map((q) => q.id),
       },
     } as unknown as Invoice,
   });
 
+  // When slippage exceeded, create PaymentIntent with requires_action status for manual payment
+  if (shouldMarkOverdue && invoice) {
+    const paymentIntent = await PaymentIntent.create({
+      livemode: !!invoice.livemode,
+      amount: invoice.amount_remaining || safeFinalTotal,
+      amount_received: '0',
+      amount_capturable: '0',
+      customer_id: invoice.customer_id,
+      description: 'Slippage exceeded - manual payment required',
+      currency_id: invoice.currency_id,
+      payment_method_id: invoice.default_payment_method_id,
+      invoice_id: invoice.id,
+      status: 'requires_action',
+      capture_method: 'manual',
+      confirmation_method: 'manual',
+      payment_method_types: [],
+      receipt_email: customer.email,
+      statement_descriptor: invoice.statement_descriptor,
+      statement_descriptor_suffix: '',
+      setup_future_usage: 'on_session',
+      metadata: {
+        slippage_exceeded: true,
+        current_rate: slippageCheck?.currentRate,
+        min_acceptable_rate: slippageCheck?.minAcceptableRate,
+      },
+    });
+
+    await invoice.update({ payment_intent_id: paymentIntent.id });
+
+    logger.info('PaymentIntent created for slippage exceeded invoice', {
+      invoiceId: invoice.id,
+      paymentIntentId: paymentIntent.id,
+      amount: paymentIntent.amount,
+      currentRate: slippageCheck?.currentRate,
+      minAcceptableRate: slippageCheck?.minAcceptableRate,
+    });
+
+    // Send notification for slippage exceeded
+    events.emit('subscription.slippage_exceeded', subscription, {
+      invoiceId: invoice.id,
+      paymentIntentId: paymentIntent.id,
+      currentRate: slippageCheck?.currentRate,
+      minAcceptableRate: slippageCheck?.minAcceptableRate,
+    });
+  }
+
+  if (shouldMarkOverdue && !['past_due', 'canceled', 'incomplete_expired'].includes(subscription.status)) {
+    await subscription.update({
+      status: 'past_due',
+      cancelation_details: {
+        comment: 'past_due',
+        feedback: 'other',
+        reason: 'slippage_below_threshold',
+      },
+    });
+    logger.warn('Subscription moved to past_due due to slippage threshold', {
+      subscription: subscription.id,
+      invoice: invoice.id,
+      currentRate: slippageCheck?.currentRate,
+      minAcceptableRate: slippageCheck?.minAcceptableRate,
+    });
+  }
+
   logger.info('Invoice created for subscription', { invoice: invoice.id, subscription: subscription.id });
 
   return invoice;
@@ -318,9 +516,26 @@ const doHandleSubscriptionInvoice = async ({
 export async function handleSubscriptionInvoice(args: Parameters<typeof doHandleSubscriptionInvoice>[0]) {
   const lock = getLock(`${args.subscription.id}-invoice`);
   await lock.acquire();
-  const result = await doHandleSubscriptionInvoice(args);
-  lock.release();
-  return result;
+  try {
+    const result = await doHandleSubscriptionInvoice(args);
+    return result;
+  } catch (error: any) {
+    // Log non-retryable errors with more context
+    if (error instanceof NonRetryableError) {
+      logger.error('Non-retryable error in subscription invoice generation', {
+        subscriptionId: args.subscription.id,
+        errorCode: error.code,
+        errorMessage: error.message,
+        reason: args.reason,
+        periodStart: args.start,
+        periodEnd: args.end,
+      });
+    }
+    throw error;
+  } finally {
+    // Always release lock, even if error occurs
+    lock.release();
+  }
 }
 
 const handleSubscriptionBeforeCancel = async (subscription: Subscription) => {
@@ -1513,11 +1728,24 @@ export async function addSubscriptionJob(
   }
   if (action === 'cycle') {
     if (!cycleJob || (replace && cycleJob)) {
+      const renewalTime = runAt || subscription.current_period_end;
       await subscriptionQueue[fn]({
         id: jobId,
         job: { subscriptionId: subscription.id, action },
-        runAt: runAt || subscription.current_period_end,
+        runAt: renewalTime,
       });
+
+      // Schedule slippage pre-check 1 hour before renewal for dynamic pricing subscriptions
+      try {
+        await scheduleSlippagePreCheck(subscription, renewalTime);
+      } catch (error) {
+        // Log but don't fail the main job scheduling
+        logger.error('Failed to schedule slippage pre-check', {
+          subscriptionId: subscription.id,
+          renewalTime,
+          error,
+        });
+      }
     }
   } else {
     await subscriptionQueue.delete(jobId);
@@ -1526,6 +1754,18 @@ export async function addSubscriptionJob(
       job: { subscriptionId: subscription.id, action },
       runAt: runAt || subscription.current_period_end,
     });
+
+    // Cancel slippage pre-check when subscription is being cancelled
+    if (action === 'cancel') {
+      try {
+        await cancelSlippagePreCheck(subscription.id);
+      } catch (error) {
+        logger.error('Failed to cancel slippage pre-check', {
+          subscriptionId: subscription.id,
+          error,
+        });
+      }
+    }
   }
 }
 
@@ -1724,3 +1964,193 @@ events.on('setup_intent.succeeded', async (setupIntent: SetupIntent) => {
     }
   }
 });
+
+// ============= Slippage Pre-Check Job =============
+// Checks slippage 1 hour before subscription renewal and sends warning notification if below threshold
+
+type SlippagePreCheckJob = {
+  subscriptionId: string;
+  renewalTime: number;
+};
+
+/**
+ * Handle slippage pre-check: Check if current exchange rate is below min acceptable rate
+ * before subscription renewal and send warning notification
+ */
+async function handleSlippagePreCheck(job: SlippagePreCheckJob): Promise<void> {
+  const { subscriptionId, renewalTime } = job;
+
+  const subscription = await Subscription.findByPk(subscriptionId);
+  if (!subscription) {
+    logger.warn('Slippage pre-check: Subscription not found', { subscriptionId });
+    return;
+  }
+
+  // Skip if subscription is not in active status
+  if (!['active', 'trialing'].includes(subscription.status)) {
+    logger.info('Slippage pre-check: Skipping non-active subscription', {
+      subscriptionId,
+      status: subscription.status,
+    });
+    return;
+  }
+
+  // Skip if no slippage config - having slippage_config means it's a dynamic pricing subscription
+  const slippageConfig = subscription.slippage_config;
+  if (!slippageConfig || !slippageConfig.min_acceptable_rate) {
+    logger.info('Slippage pre-check: No slippage config or min_acceptable_rate', { subscriptionId });
+    return;
+  }
+
+  // Get payment currency and payment method
+  const paymentCurrency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!paymentCurrency) {
+    logger.info('Slippage pre-check: Payment currency not found', { subscriptionId });
+    return;
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+  if (!paymentMethod) {
+    logger.info('Slippage pre-check: Payment method not found', { subscriptionId });
+    return;
+  }
+
+  // Get current exchange rate
+  try {
+    const exchangeRateService = getExchangeRateService();
+    const rateSymbol = getExchangeRateSymbol(paymentCurrency.symbol, paymentMethod.type as any);
+
+    if (!rateSymbol) {
+      logger.info('Slippage pre-check: No exchange rate symbol for currency', {
+        subscriptionId,
+        currencyId: paymentCurrency.id,
+        symbol: paymentCurrency.symbol,
+      });
+      return;
+    }
+
+    const rateResult = await exchangeRateService.getRate(rateSymbol);
+    const currentRate = rateResult?.rate;
+
+    if (!currentRate) {
+      logger.warn('Slippage pre-check: Failed to get current exchange rate', {
+        subscriptionId,
+        rateSymbol,
+      });
+      return;
+    }
+
+    const belowThreshold = isRateBelowMinAcceptableRate(String(currentRate), slippageConfig.min_acceptable_rate);
+
+    if (belowThreshold) {
+      // Emit warning notification event
+      events.emit('subscription.slippage_warning', subscription, {
+        currentRate: String(currentRate),
+        minAcceptableRate: slippageConfig.min_acceptable_rate,
+        renewalTime,
+      });
+
+      logger.info('Slippage pre-check: Warning sent due to rate below threshold', {
+        subscriptionId,
+        currentRate,
+        minAcceptableRate: slippageConfig.min_acceptable_rate,
+        renewalTime,
+      });
+    } else {
+      logger.info('Slippage pre-check: Rate is acceptable', {
+        subscriptionId,
+        currentRate,
+        minAcceptableRate: slippageConfig.min_acceptable_rate,
+      });
+    }
+  } catch (error) {
+    logger.error('Slippage pre-check: Failed to check exchange rate', {
+      subscriptionId,
+      error,
+    });
+  }
+}
+
+export const slippagePreCheckQueue = createQueue<SlippagePreCheckJob>({
+  name: 'slippage_pre_check',
+  onJob: handleSlippagePreCheck,
+  options: {
+    concurrency: 10,
+    maxRetries: 3,
+    retryDelay: 60000, // 1 minute
+    maxTimeout: 60000,
+    enableScheduledJob: true,
+  },
+});
+
+/**
+ * Schedule slippage pre-check job 1 hour before subscription renewal
+ * Should be called when scheduling the cycle job
+ */
+export async function scheduleSlippagePreCheck(subscription: Subscription, renewalTime: number): Promise<void> {
+  // Only schedule for subscriptions with slippage config and min_acceptable_rate
+  // Having slippage_config means it's a dynamic pricing subscription
+  const slippageConfig = subscription.slippage_config;
+  if (!slippageConfig || !slippageConfig.min_acceptable_rate) {
+    return;
+  }
+
+  // Schedule pre-check 1 hour before renewal
+  const preCheckTime = renewalTime - 3600; // 1 hour before
+  const now = Math.floor(Date.now() / 1000);
+
+  // Only schedule if pre-check time is in the future
+  if (preCheckTime <= now) {
+    logger.info('Slippage pre-check: Pre-check time is in the past, skipping', {
+      subscriptionId: subscription.id,
+      renewalTime,
+      preCheckTime,
+      now,
+    });
+    return;
+  }
+
+  const jobId = `slippage-pre-check-${subscription.id}-${renewalTime}`;
+
+  // Delete existing job if any
+  await slippagePreCheckQueue.delete(jobId);
+
+  await slippagePreCheckQueue.push({
+    id: jobId,
+    job: {
+      subscriptionId: subscription.id,
+      renewalTime,
+    },
+    runAt: preCheckTime,
+  });
+
+  logger.info('Slippage pre-check: Job scheduled', {
+    subscriptionId: subscription.id,
+    renewalTime,
+    preCheckTime,
+    jobId,
+  });
+}
+
+/**
+ * Cancel slippage pre-check job for a subscription
+ */
+export async function cancelSlippagePreCheck(subscriptionId: string, renewalTime?: number): Promise<void> {
+  if (renewalTime) {
+    const jobId = `slippage-pre-check-${subscriptionId}-${renewalTime}`;
+    await slippagePreCheckQueue.delete(jobId);
+    logger.info('Slippage pre-check: Specific job cancelled', { subscriptionId, renewalTime, jobId });
+  } else {
+    // Delete all pre-check jobs for this subscription
+    // Note: This is a fallback that searches through the queue
+    const jobs = await slippagePreCheckQueue.store.findJobs({});
+    // eslint-disable-next-line no-await-in-loop
+    for (const job of jobs) {
+      if (job.job?.subscriptionId === subscriptionId) {
+        // eslint-disable-next-line no-await-in-loop
+        await slippagePreCheckQueue.delete(job.id);
+        logger.info('Slippage pre-check: Job cancelled', { subscriptionId, jobId: job.id });
+      }
+    }
+  }
+}

package/api/src/routes/auto-recharge-configs.ts

@@ -6,6 +6,7 @@ import { Op } from 'sequelize';
 import { sessionMiddleware } from '@blocklet/sdk/lib/middlewares/session';
 import { BN, fromTokenToUnit, fromUnitToToken } from '@ocap/util';
 import { trimDecimals } from '../libs/math-utils';
+import { applySlippageToAmount } from '../libs/slippage';
 import {
   AutoRechargeConfig,
   Customer,
@@ -25,6 +26,20 @@ import logger from '../libs/logger';
 
 const router = Router();
 
+const slippageConfigSchema = Joi.object({
+  mode: Joi.string().valid('percent', 'rate').optional(),
+  // In rate mode, percent is calculated from min_acceptable_rate and can exceed 100%
+  // In percent mode, percent is user-specified and should be 0-100
+  percent: Joi.when('mode', {
+    is: 'rate',
+    then: Joi.number().min(0).optional(),
+    otherwise: Joi.number().min(0).max(100).optional(),
+  }),
+  min_acceptable_rate: Joi.string().optional(),
+  base_currency: Joi.string().optional(),
+  updated_at_ms: Joi.number().optional(),
+}).allow(null);
+
 const createConfigSchema = Joi.object({
   customer_id: Joi.string().required(),
   enabled: Joi.boolean().default(false),
@@ -39,6 +54,7 @@ const createConfigSchema = Joi.object({
     max_attempts: Joi.number().integer().min(0).default(0).optional(),
     max_amount: Joi.number().min(0).default(0).optional(),
   }).optional(),
+  slippage_config: slippageConfigSchema.optional(),
 });
 
 const getConfigSchema = Joi.object({
@@ -80,6 +96,23 @@ async function ensurePaymentMethodExists(paymentMethodId: string): Promise<Payme
   return paymentMethod;
 }
 
+// Check if slippage_config has changed in a way that requires reauthorization
+function hasSlippageConfigChanged(
+  oldConfig: AutoRechargeConfig['slippage_config'],
+  newConfig: AutoRechargeConfig['slippage_config']
+): boolean {
+  // If both are empty, no change
+  if (!oldConfig && !newConfig) return false;
+  // If one is empty and the other is not, there's a change
+  if (!oldConfig || !newConfig) return true;
+  // Compare key fields that affect authorization amount
+  return (
+    oldConfig.mode !== newConfig.mode ||
+    oldConfig.percent !== newConfig.percent ||
+    oldConfig.min_acceptable_rate !== newConfig.min_acceptable_rate
+  );
+}
+
 // Apply balance check results to configuration
 async function applyBalanceCheckResults(
   config: AutoRechargeConfig,
@@ -199,7 +232,10 @@ router.get('/customer/:customerId', sessionMiddleware({ accessKey: true }), asyn
     return res.json({
       ...newConfig.toJSON(),
       currency,
-      price,
+      price: {
+        ...price.toJSON(),
+        pricing_type: price.pricing_type || 'fixed',
+      },
       threshold: fromUnitToToken(minimumThreshold, currency.decimal),
       customer,
     });
@@ -221,7 +257,10 @@ router.get('/customer/:customerId', sessionMiddleware({ accessKey: true }), asyn
       max_amount: fromUnitToToken(config.daily_limits?.max_amount || '0', config.rechargeCurrency?.decimal || 2),
     },
     currency,
-    price,
+    price: {
+      ...price.toJSON(),
+      pricing_type: price.pricing_type || 'fixed',
+    },
     threshold: fromUnitToToken(configThreshold, currency.decimal),
     customer,
   });
@@ -261,7 +300,20 @@ async function checkSufficientBalance({
   forceReauthorize?: boolean;
 }) {
   const priceAmount = await getPriceUintAmountByCurrency(price, rechargeCurrency.id);
-  const amount = new BN(priceAmount).mul(new BN(quantity));
+  let amount = new BN(priceAmount).mul(new BN(quantity));
+
+  // Apply slippage buffer for dynamic pricing authorization
+  // This ensures the delegation covers the maximum possible payment amount
+  const slippagePercent = autoRechargeConfig.slippage_config?.percent;
+  if (slippagePercent && slippagePercent > 0) {
+    amount = applySlippageToAmount(amount, slippagePercent);
+    logger.info('Applied slippage to authorization amount', {
+      baseAmount: new BN(priceAmount).mul(new BN(quantity)).toString(),
+      slippagePercent,
+      authorizedAmount: amount.toString(),
+    });
+  }
+
   const paymentMethod = await PaymentMethod.findByPk(rechargeCurrency.payment_method_id);
 
   if (!paymentMethod) {
@@ -425,7 +477,7 @@ router.post('/submit', async (req, res) => {
       });
     }
     // if exist, update it
-    await existingConfig.update({
+    const updateData: any = {
       ...configData,
       currency_id: value.currency_id,
       recharge_currency_id: value.recharge_currency_id,
@@ -433,7 +485,19 @@ router.post('/submit', async (req, res) => {
       payment_method_id: rechargeCurrency.payment_method_id,
       threshold: threshold ?? existingConfig.threshold,
       daily_limits: dailyLimits,
-    });
+    };
+    // Only update slippage_config if explicitly provided (including null to clear it)
+    if ('slippage_config' in value) {
+      updateData.slippage_config = value.slippage_config;
+    }
+
+    // Check if slippage_config changed BEFORE updating (to compare old vs new)
+    const slippageConfigChanged =
+      'slippage_config' in value && hasSlippageConfigChanged(existingConfig.slippage_config, value.slippage_config);
+
+    await existingConfig.update(updateData);
+
+    // If slippage_config changed, need to reauthorize because authorization amount may change
     const balanceResult = await checkSufficientBalance({
       price: price as unknown as Price,
       quantity: value.quantity,
@@ -441,7 +505,7 @@ router.post('/submit', async (req, res) => {
       userDid: customer.did,
       customer,
       autoRechargeConfig: existingConfig,
-      forceReauthorize: value.change_payment_method,
+      forceReauthorize: value.change_payment_method || slippageConfigChanged,
     });
     // Update payment details and settings based on balance check result
     await applyBalanceCheckResults(existingConfig, balanceResult, paymentMethod);
@@ -464,6 +528,7 @@ router.post('/submit', async (req, res) => {
     quantity: Number(configData.quantity || '1'),
     payment_method_id: rechargeCurrency.payment_method_id,
     daily_limits: dailyLimits,
+    slippage_config: value.slippage_config,
   });
 
   logger.info('Auto recharge config created', {