payment-kit 1.16.17 → 1.16.19

package/api/src/libs/subscription.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-await-in-loop */
 import component from '@blocklet/sdk/lib/component';
-import { BN } from '@ocap/util';
+import { BN, fromUnitToToken } from '@ocap/util';
 import isEmpty from 'lodash/isEmpty';
 import trim from 'lodash/trim';
 import pick from 'lodash/pick';
@@ -14,6 +14,7 @@ import {
   InvoiceItem,
   Lock,
   PaymentCurrency,
+  PaymentIntent,
   PaymentMethod,
   Price,
   PriceRecurring,
@@ -31,6 +32,10 @@ import env from './env';
 import logger from './logger';
 import { getPriceCurrencyOptions, getPriceUintAmountByCurrency, getRecurringPeriod } from './session';
 import { getConnectQueryParam, getCustomerStakeAddress } from './util';
+import { wallet } from './auth';
+import { getGasPayerExtra } from './payment';
+import { getLock } from './lock';
+import { emitAsync } from './event';
 
 export function getCustomerSubscriptionPageUrl({
   subscriptionId,
@@ -307,7 +312,7 @@ export async function createProration(
     return {
       lastInvoice,
       total: '0',
-      due: '0',
+      shouldPay: '0',
       used: '0',
       unused: '0',
       prorations: [],
@@ -522,6 +527,77 @@ export async function getUpcomingInvoiceAmount(subscriptionId: string) {
   };
 }
 
+export async function getPastInvoicesAmount(subscriptionId: string, aggregationRule: 'sum' | 'avg' | 'max' = 'max') {
+  const subscription = await Subscription.findByPk(subscriptionId);
+  if (!subscription) {
+    throw new Error('Subscription not found');
+  }
+
+  const currency = await PaymentCurrency.findByPk(subscription.currency_id);
+
+  // 获取所有的账单周期
+  const pastInvoices = await Invoice.findAll({
+    where: {
+      subscription_id: subscriptionId,
+      currency_id: subscription.currency_id,
+      billing_reason: [
+        'subscription_create',
+        'subscription_cycle',
+        'subscription_update',
+        'subscription_recover',
+        'subscription_threshold',
+        'subscription_cancel',
+        'subscription',
+      ],
+    },
+    order: [['created_at', 'DESC']],
+  });
+
+  const setup = getSubscriptionCycleSetup(subscription.pending_invoice_item_interval, subscription.current_period_end);
+  let start = setup.period.start - setup.cycle / 1000;
+  let end = setup.period.end - setup.cycle / 1000;
+  const createdAt = dayjs(subscription.created_at).unix();
+  const amountsByPeriod: { [key: string]: BN } = {};
+
+  while (start < end && start >= createdAt) {
+    const periodKey = `${start}-${end}`;
+    // eslint-disable-next-line @typescript-eslint/no-loop-func
+    const invoices = pastInvoices.filter((x) => x.period_start >= start && x.period_end <= end);
+    const amount = invoices.reduce((acc, x) => acc.add(new BN(x.total)), new BN(0));
+    amountsByPeriod[periodKey] = amount;
+    start -= setup.cycle / 1000;
+    end -= setup.cycle / 1000;
+  }
+
+  let result = new BN(0);
+  switch (aggregationRule) {
+    case 'sum':
+      result = Object.values(amountsByPeriod).reduce((acc, curr) => acc.add(curr), new BN(0));
+      break;
+    case 'avg':
+      result =
+        Object.values(amountsByPeriod).length > 0
+          ? Object.values(amountsByPeriod)
+              .reduce((acc, curr) => acc.add(curr), new BN(0))
+              .div(new BN(Object.values(amountsByPeriod).length))
+          : new BN(0);
+      break;
+    case 'max':
+      result =
+        Object.values(amountsByPeriod).length > 0
+          ? Object.values(amountsByPeriod).reduce((acc, curr) => (acc.gt(curr) ? acc : curr), new BN(0))
+          : new BN(0);
+      break;
+    default:
+      throw new Error('Invalid aggregation rule');
+  }
+
+  return {
+    amount: result.toString(),
+    currency,
+  };
+}
+
 export async function finalizeSubscriptionUpdate({
   subscription,
   customer,
@@ -1033,3 +1109,457 @@ export function getSubscriptionPaymentAddress(subscription: Subscription, paymen
     subscription.payment_settings?.payment_method_options?.[paymentMethodType]?.payer
   );
 }
+export async function getPaymentAmountForCycleSubscription(
+  subscription: Subscription,
+  paymentCurrency: PaymentCurrency
+) {
+  const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
+  if (subscriptionItems.length === 0) {
+    logger.info('subscription items not found in getPaymentAmountForCycleSubscription', {
+      subscription: subscription.id,
+    });
+    return 0;
+  }
+  let expandedItems = await Price.expand(
+    subscriptionItems.map((x) => ({ id: x.id, price_id: x.price_id, quantity: x.quantity })),
+    { product: true }
+  );
+  if (expandedItems.length === 0) {
+    logger.info('expanded items not found in getPaymentAmountForCycleSubscription', {
+      subscription: subscription.id,
+    });
+    return 0;
+  }
+  const previousPeriodEnd =
+    subscription.status === 'trialing' ? subscription.trial_end : subscription.current_period_end;
+  const setup = getSubscriptionCycleSetup(subscription.pending_invoice_item_interval, previousPeriodEnd as number);
+  // get usage summaries for this billing cycle
+  expandedItems = await Promise.all(
+    expandedItems.map(async (x: any) => {
+      // For metered billing, we need to get usage summary for this billing cycle
+      // @link https://stripe.com/docs/products-prices/pricing-models#usage-types
+      if (x.price.recurring?.usage_type === 'metered') {
+        const rawQuantity = await UsageRecord.getSummary({
+          id: x.id,
+          start: setup.period.start - setup.cycle / 1000,
+          end: setup.period.end - setup.cycle / 1000,
+          method: x.price.recurring?.aggregate_usage,
+          dryRun: true,
+        });
+        x.quantity = x.price.transformQuantity(rawQuantity);
+        // record raw quantity in metadata
+        x.metadata = x.metadata || {};
+        x.metadata.quantity = rawQuantity;
+      }
+      return x;
+    })
+  );
+  if (expandedItems.length > 0) {
+    const amount = getSubscriptionCycleAmount(expandedItems, paymentCurrency.id);
+    return +fromUnitToToken(amount?.total || '0', paymentCurrency.decimal);
+  }
+  return 0;
+}
+
+// check if subscription overdraft protection is enabled
+export async function isSubscriptionOverdraftProtectionEnabled(subscription: Subscription, paymentCurrencyId?: string) {
+  try {
+    const paymentCurrency = await PaymentCurrency.findByPk(paymentCurrencyId || subscription.currency_id);
+    if (!paymentCurrency) {
+      throw new Error(`PaymentCurrency not found in ${subscription.id}`);
+    }
+    const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+    if (!paymentMethod) {
+      throw new Error(`PaymentMethod not found in ${subscription.id}`);
+    }
+
+    if (paymentMethod.type !== 'arcblock') {
+      throw new Error(`PaymentMethod type not supported in ${subscription.id}`);
+    }
+    if (!subscription.overdraft_protection) {
+      return {
+        enabled: false,
+        remaining: '0',
+        used: '0',
+        shouldPay: '0',
+        unused: '0',
+        revokedStake: '0',
+      };
+    }
+    const client = paymentMethod.getOcapClient();
+    const address = subscription?.overdraft_protection?.payment_details?.arcblock?.staking?.address;
+    if (!address) {
+      logger.info('Seems you have no staking for overdraft protection', { subscription: subscription.id });
+      return {
+        enabled: false,
+        remaining: '0',
+        used: '0',
+        shouldPay: '0',
+        unused: '0',
+        revokedStake: '0',
+      };
+    }
+    const { state } = await client.getStakeState({ address });
+    if (!state) {
+      throw new Error(`Stake state not found in ${subscription.id}`);
+    }
+    const data = JSON.parse(state.data?.value || '{}');
+    if (!data[subscription.id] && !state.nonce) {
+      throw new Error(`No staking for subscription: ${subscription.id}, address: ${address}`);
+    }
+
+    // calculate remaining stake, need to subtract refunding amount
+    let remainingStake = new BN(state.tokens.find((x: any) => x.address === paymentCurrency.contract)?.value || '0');
+    const revokedStake = new BN(
+      state.revokedTokens?.find((x: any) => x.address === paymentCurrency.contract)?.value || '0'
+    );
+
+    const refunds = await Refund.findAll({
+      where: {
+        subscription_id: subscription.id,
+        type: 'stake_return',
+        status: {
+          [Op.notIn]: ['canceled', 'succeeded'],
+        },
+        currency_id: paymentCurrency.id,
+      },
+      include: [{ model: Invoice, as: 'invoice' }],
+    });
+    const refundAmount = refunds
+      .filter((x: any) => x.invoice?.billing_reason === 'stake_overdraft_protection')
+      .reduce((acc, x) => acc.add(new BN(x.amount)), new BN(0));
+    remainingStake = remainingStake.sub(refundAmount);
+
+    const invoices = await Invoice.findAll({
+      where: {
+        subscription_id: subscription.id,
+        status: ['open', 'uncollectible'],
+        currency_id: paymentCurrency.id,
+      },
+    });
+    let usedAmount = new BN(0);
+    let dueAmount = new BN(0);
+    invoices.forEach((invoice) => {
+      usedAmount = usedAmount.add(new BN(invoice.amount_remaining));
+      if (invoice.billing_reason !== 'overdraft_protection') {
+        dueAmount = dueAmount.add(new BN(invoice.amount_remaining));
+      }
+    });
+    return {
+      enabled: subscription.overdraft_protection.enabled && usedAmount.lte(remainingStake),
+      remaining: remainingStake.toString(),
+      used: usedAmount.toString(),
+      shouldPay: dueAmount.toString(),
+      revoked: revokedStake.toString(),
+      unused: remainingStake.gte(usedAmount) ? remainingStake.sub(usedAmount).toString() : '0',
+    };
+  } catch (error) {
+    logger.error('error in isSubscriptionOverdraftProtectionEnabled', { error });
+    return {
+      enabled: false,
+      remaining: '0',
+      used: '0',
+      unused: '0',
+      shouldPay: '0',
+      revokedStake: '0',
+    };
+  }
+}
+
+// return remaining overdraft protection stake to customer
+export async function returnOverdraftProtectionStake(
+  subscription: Subscription,
+  paymentCurrencyId?: string,
+  refundReason?: string
+) {
+  // return remaining stake to customer
+  logger.info('returnOverdraftProtectionStake', { subscription: subscription.id, paymentCurrencyId });
+  try {
+    await slashOverdraftProtectionStake(subscription, paymentCurrencyId);
+    const { unused } = await isSubscriptionOverdraftProtectionEnabled(subscription, paymentCurrencyId);
+    if (unused !== '0') {
+      // return unused stake to customer
+      const address = subscription?.overdraft_protection?.payment_details?.arcblock?.staking?.address;
+      if (!address) {
+        logger.info('Stake return skipped due to missing staking address', { subscription: subscription.id });
+        return;
+      }
+      const invoice = await Invoice.findOne({
+        where: {
+          subscription_id: subscription.id,
+          billing_reason: 'stake_overdraft_protection',
+          currency_id: paymentCurrencyId || subscription.currency_id,
+          status: 'paid',
+        },
+        order: [['created_at', 'DESC']],
+      });
+      const item = await Refund.create({
+        type: 'stake_return',
+        amount: unused,
+        description: 'overdraft protection_return_for_subscription',
+        status: 'pending',
+        reason: refundReason || 'requested_by_admin',
+        subscription_id: subscription.id,
+        currency_id: paymentCurrencyId || subscription.currency_id,
+        livemode: subscription.livemode,
+        customer_id: subscription.customer_id,
+        invoice_id: invoice?.id,
+        payment_intent_id: invoice?.payment_intent_id || '',
+        payment_method_id: subscription.overdraft_protection?.payment_method_id || '',
+        starting_balance: unused,
+        ending_balance: '0',
+        attempt_count: 0,
+        attempted: false,
+        next_attempt: 0,
+        last_attempt_error: null,
+        starting_token_balance: {},
+        ending_token_balance: {},
+        payment_details: {
+          // @ts-ignore
+          arcblock: {
+            receiver:
+              subscription?.overdraft_protection?.payment_details?.arcblock?.payer ||
+              getSubscriptionPaymentAddress(subscription, 'arcblock'),
+            staking: {
+              address: address || '',
+              tx_hash: '',
+            },
+          },
+        },
+      });
+      logger.info('returnOverdraftProtectionStake Refund created', { item });
+    }
+  } catch (error) {
+    logger.error('returnOverdraftProtectionStake failed', { error });
+    throw error;
+  }
+}
+
+// slash overdraft protection stake
+export async function slashOverdraftProtectionStake(subscription: Subscription, paymentCurrencyId?: string) {
+  const lock = getLock(
+    `slash_overdraft_protection_stake_${subscription.id}-${paymentCurrencyId || subscription.currency_id}`
+  );
+  logger.info('slashOverdraftProtectionStake', { subscription: subscription.id, paymentCurrencyId });
+  try {
+    await lock.acquire();
+    if (!subscription.overdraft_protection) {
+      logger.info('slashOverdraftProtectionStake skipped due to missing overdraft protection', {
+        subscription: subscription.id,
+      });
+      return;
+    }
+
+    const paymentCurrency = await PaymentCurrency.findByPk(paymentCurrencyId || subscription.currency_id);
+    if (!paymentCurrency) {
+      throw new Error(`PaymentCurrency not found in ${subscription.id}`);
+    }
+
+    const { used, remaining, revoked } = await isSubscriptionOverdraftProtectionEnabled(
+      subscription,
+      paymentCurrency.id
+    );
+    const remainingStake = new BN(remaining).add(new BN(revoked)).toString();
+    if (used === '0') {
+      logger.info('slashOverdraftProtectionStake skipped due to no unpaid invoices', {
+        subscription: subscription.id,
+        paymentCurrencyId: paymentCurrency.id,
+      });
+      return;
+    }
+
+    if (remainingStake === '0') {
+      logger.info('slashOverdraftProtectionStake skipped due to no remaining stake', {
+        subscription: subscription.id,
+        paymentCurrencyId: paymentCurrency.id,
+      });
+      return;
+    }
+
+    const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+    if (!paymentMethod || paymentMethod.type !== 'arcblock') {
+      throw new Error(`PaymentMethod type not supported in ${subscription.id}`);
+    }
+
+    const address = subscription?.overdraft_protection?.payment_details?.arcblock?.staking?.address;
+
+    if (!address) {
+      // no staking address
+      logger.info('Stake slashing skipped due to missing staking address', { subscription: subscription.id });
+      return;
+    }
+
+    const client = paymentMethod.getOcapClient();
+    const { state } = await client.getStakeState({ address });
+
+    if (!state || !state.data?.value) {
+      throw new Error(
+        `Stake slashing aborted due to missing staking state for subscription: ${subscription.id}, address: ${address}`
+      );
+    }
+
+    const data = JSON.parse(state.data.value || '{}');
+    if (!data[subscription.id] && !state.nonce) {
+      throw new Error(
+        `Stake slashing aborted because no staking for subscription: ${subscription.id}, address: ${address}`
+      );
+    }
+
+    const invoices = await Invoice.findAll({
+      where: {
+        subscription_id: subscription.id,
+        status: ['open', 'uncollectible'],
+        currency_id: paymentCurrency.id,
+      },
+      order: [['created_at', 'ASC']],
+    });
+
+    let slashAmount = new BN(0);
+    const slashInvoices: Invoice[] = [];
+    const updatePromises = invoices.map(async (invoice) => {
+      if (!invoice.payment_intent_id) {
+        await emitAsync(
+          'invoice.queued',
+          invoice.id,
+          { invoiceId: invoice.id, retryOnError: false, justCreate: true },
+          {
+            sync: true,
+          }
+        );
+        await invoice.reload();
+      }
+      const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
+      if (paymentIntent) {
+        if (paymentIntent.status === 'succeeded' && invoice.status === 'paid') {
+          logger.info('PaymentIntent and Invoice already updated', {
+            subscription: subscription.id,
+            paymentIntent: paymentIntent.id,
+            invoice: invoice.id,
+          });
+          return;
+        }
+        const tmp = slashAmount.add(new BN(invoice.amount_remaining));
+
+        if (tmp.lte(new BN(remainingStake))) {
+          slashAmount = tmp;
+          slashInvoices.push(invoice);
+          try {
+            const stakeEnough = await checkRemainingStake(
+              paymentMethod,
+              paymentCurrency,
+              address,
+              invoice.amount_remaining
+            );
+            if (!stakeEnough.enough) {
+              throw new Error(`Stake slashing aborted because no enough staking for invoice: ${invoice.id}`);
+            }
+            // do the slash
+            const signed = await client.signSlashStakeTx({
+              tx: {
+                itx: {
+                  address,
+                  outputs: [
+                    {
+                      owner: wallet.address,
+                      tokens: [{ address: paymentCurrency.contract, value: invoice.amount_remaining }],
+                    },
+                  ],
+                  message: 'overdraft_exceeded',
+                  data: {
+                    typeUrl: 'json',
+                    // @ts-ignore
+                    value: {
+                      appId: wallet.address,
+                      reason: 'overdraft_exceeded',
+                      subscriptionId: subscription.id,
+                      invoiceId: invoice.id,
+                      paymentIntentId: paymentIntent.id,
+                    },
+                  },
+                },
+              },
+              wallet,
+            });
+            // @ts-ignore
+            const { buffer } = await client.encodeSlashStakeTx({ tx: signed });
+            // @ts-ignore
+            const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+
+            await paymentIntent.update({
+              status: 'succeeded',
+              amount_received: invoice.amount_remaining,
+              capture_method: 'manual',
+              last_payment_error: null,
+              payment_details: {
+                arcblock: {
+                  tx_hash: txHash,
+                  payer:
+                    subscription.overdraft_protection?.payment_details?.arcblock?.payer ||
+                    getSubscriptionPaymentAddress(subscription, 'arcblock'),
+                  type: 'slash',
+                },
+              },
+            });
+            logger.info('PaymentIntent updated after stake slash', {
+              subscription: subscription.id,
+              paymentIntent: paymentIntent.id,
+              status: 'succeeded',
+            });
+
+            await invoice.update({
+              status: 'paid',
+              paid: true,
+              amount_paid: invoice.amount_remaining,
+              amount_remaining: '0',
+              attempted: true,
+              attempt_count: invoice.attempt_count + 1,
+              status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
+            });
+            logger.info('Invoice updated after stake slash', {
+              subscription: subscription.id,
+              invoice: invoice.id,
+              status: 'paid',
+            });
+          } catch (updateError) {
+            logger.error('stake slash failed', {
+              subscription: subscription.id,
+              invoice: invoice.id,
+              error: updateError,
+            });
+            throw updateError;
+          }
+        }
+      }
+    });
+
+    await Promise.all(updatePromises);
+    logger.info(`${slashInvoices.length} invoices updated after stake slash`, {
+      subscription: subscription.id,
+      invoices: slashInvoices.map((x) => x.id),
+      slashAmount: slashAmount.toString(),
+    });
+  } catch (error) {
+    logger.error('Error in slashOverdraftProtectionStake', { error });
+    throw error;
+  } finally {
+    lock.release();
+  }
+}
+
+export async function getSubscriptionUnpaidInvoicesCount(subscription: Subscription) {
+  try {
+    const count = await Invoice.count({
+      where: {
+        subscription_id: subscription.id,
+        status: ['open', 'uncollectible'],
+        billing_reason: {
+          [Op.notIn]: ['overdraft_protection'],
+        },
+      },
+    });
+    return count;
+  } catch (error) {
+    logger.error('getSubscriptionUnpaidInvoicesCount failed', { error });
+    return 0;
+  }
+}

package/api/src/libs/util.ts

@@ -372,3 +372,7 @@ export function getAdminBillingSubscriptionUrl({
 }) {
   return getUrl(withQuery(`admin/billing/${subscriptionId}`, { locale, ...getConnectQueryParam({ userDid }) }));
 }
+
+export function getCustomerIndexUrl({ locale, userDid }: { locale: string; userDid: string }) {
+  return getUrl(withQuery('customer', { locale, ...getConnectQueryParam({ userDid }) }));
+}

package/api/src/locales/en.ts

@@ -192,5 +192,10 @@ export default flat({
       paymentFailed: 'Payment failed',
       stakeRevoked: 'Stake revoked',
     },
+
+    overdraftProtectionExhausted: {
+      title: 'Insufficient Credit for Overdraft Protection',
+      body: 'Your subscription to {productName} has insufficient staked credit for overdraft protection. Please increase your stake to maintain the service or disable it if no longer needed.',
+    },
   },
 });

package/api/src/locales/zh.ts

@@ -185,5 +185,10 @@ export default flat({
       paymentFailed: '扣费失败',
       stakeRevoked: '撤销质押',
     },
+
+    overdraftProtectionExhausted: {
+      title: '透支保护额度不足',
+      body: '您订阅的 {productName} 透支保护额度不足，为了避免影响您的透支保护服务，请及时充值。如不再需要透支保护服务，可关闭该功能。',
+    },
   },
 });

package/api/src/queues/event.ts

@@ -59,6 +59,7 @@ export const handleEvent = async (job: EventJob) => {
         webhookQueue.push({
           id: jobId,
           job: { eventId: event.id, webhookId: webhook.id },
+          persist: false,
         });
       }
     }
@@ -90,7 +91,7 @@ export const startEventQueue = async () => {
     const exist = await eventQueue.get(x.id);
     if (!exist) {
       logger.info(`Pushing event ${x.id} to queue`);
-      eventQueue.push({ id: x.id, job: { eventId: x.id } });
+      eventQueue.push({ id: x.id, job: { eventId: x.id }, persist: false });
     }
   });
 
@@ -102,5 +103,5 @@ eventQueue.on('failed', ({ id, job, error }) => {
 });
 
 events.on('event.created', (event) => {
-  eventQueue.push({ id: event.id, job: { eventId: event.id } });
+  eventQueue.push({ id: event.id, job: { eventId: event.id }, persist: false });
 });

package/api/src/queues/invoice.ts

@@ -1,7 +1,6 @@
 import { Op } from 'sequelize';
 
-import { getInvoiceShouldPayTotal } from '../libs/invoice';
-import { batchHandleStripeInvoices } from '../integrations/stripe/resource';
+import { getInvoiceShouldPayTotal, handleOverdraftProtectionInvoiceAfterPayment } from '../libs/invoice';
 import { createEvent } from '../libs/audit';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
@@ -14,6 +13,7 @@ import { paymentQueue } from './payment';
 
 import { getLock } from '../libs/lock';
 import { events } from '../libs/event';
+import { batchHandleStripeInvoices } from '../integrations/stripe/resource';
 
 type InvoiceJob = {
   invoiceId: string;
@@ -132,6 +132,7 @@ export const handleInvoice = async (job: InvoiceJob) => {
       subscription_update: 'Subscription update',
       subscription_threshold: 'Subscription threshold',
       slash_stake: 'Slash stake',
+      overdraft_protection: 'Overdraft protection',
     };
     // TODO: support partial payment from user balance
     paymentIntent = await PaymentIntent.create({
@@ -220,7 +221,7 @@ export const startInvoiceQueue = async () => {
         status: 'open',
         collection_method: 'charge_automatically',
         amount_remaining: { [Op.gt]: '0' },
-        billing_reason: { [Op.ne]: 'stake' },
+        billing_reason: { [Op.notIn]: ['stake', 'overdraft_protection'] },
       },
     });
 
@@ -276,4 +277,28 @@ events.on('invoice.paid', async ({ id: invoiceId }) => {
       logger.info('Invoice paid successfully with correct amount', { invoiceId, total: invoice.total });
     }
   }
+  await handleOverdraftProtectionInvoiceAfterPayment(invoice);
+});
+
+events.on('invoice.queued', async (id, job, args = {}) => {
+  const { sync, ...extraArgs } = args;
+  if (sync) {
+    try {
+      await invoiceQueue.pushAndWait({
+        id,
+        job,
+        ...extraArgs,
+      });
+      events.emit('invoice.queued.done');
+    } catch (error) {
+      logger.error('Error in invoice.queued', { id, job, error });
+      events.emit('invoice.queued.error', error);
+    }
+    return;
+  }
+  invoiceQueue.push({
+    id,
+    job,
+    ...extraArgs,
+  });
 });