payment-kit 1.13.18 → 1.13.20

package/api/src/integrations/stripe/resource.ts

@@ -0,0 +1,317 @@
+import env from '@blocklet/sdk/lib/env';
+import merge from 'lodash/merge';
+
+import logger from '../../libs/logger';
+import { getPriceUintAmountByCurrency } from '../../libs/session';
+import {
+  Customer,
+  PaymentCurrency,
+  PaymentIntent,
+  PaymentMethod,
+  Price,
+  Product,
+  Subscription,
+  SubscriptionItem,
+  TLineItemExpanded,
+} from '../../store/models';
+
+export async function ensureStripeProduct(internal: Product, method: PaymentMethod) {
+  const client = method.getStripe();
+  const result = await client.products.search({ query: `metadata['id']:'${internal.id}'` });
+  if (result.data.length > 0) {
+    return result.data[0] as any;
+  }
+
+  const attrs: any = {
+    name: internal.name,
+    description: internal.description,
+    metadata: {
+      appPid: env.appPid,
+      id: internal.id,
+    },
+  };
+  if (internal.unit_label) {
+    attrs.unit_label = internal.unit_label;
+  }
+  if (internal.statement_descriptor) {
+    attrs.statement_descriptor = internal.statement_descriptor;
+  }
+
+  const product = await client.products.create(attrs);
+  await internal.update({ metadata: merge(internal.metadata || {}, { stripe_id: product.id }) });
+  logger.info('product created on stripe', { local: internal.id, remote: product.id });
+
+  return product;
+}
+
+export async function ensureStripePrice(internal: Price, method: PaymentMethod, currency: PaymentCurrency) {
+  const client = method.getStripe();
+  const result = await client.prices.search({ query: `metadata['id']:'${internal.id}'` });
+  if (result.data.length > 0) {
+    return result.data[0] as any;
+  }
+
+  // create stripe product
+  const local = await Product.findByPk(internal.product_id);
+  const product = await ensureStripeProduct(local as Product, method);
+
+  const attrs: any = {
+    product: product.id,
+    currency: currency.symbol.toLowerCase(),
+    nickname: internal.nickname as string,
+    lookup_key: internal.lookup_key as string,
+    billing_scheme: internal.billing_scheme as any,
+    metadata: {
+      appPid: env.appPid,
+      id: internal.id,
+    },
+  };
+
+  if (internal.type === 'recurring') {
+    attrs.recurring = {
+      interval: internal.recurring?.interval,
+      interval_count: internal.recurring?.interval_count,
+    };
+    if (internal.recurring?.usage_type) {
+      attrs.recurring.usage_type = internal.recurring.usage_type;
+    }
+    if (internal.recurring?.usage_type === 'metered') {
+      attrs.recurring.aggregate_usage = internal.recurring.aggregate_usage;
+    }
+  }
+  if (internal.tiers_mode) {
+    attrs.tiers_mode = internal.tiers_mode;
+  }
+  if (internal.tiers_mode === 'graduated' || internal.tiers_mode === 'volume') {
+    attrs.tiers = internal.tiers;
+  } else if (internal.transform_quantity) {
+    attrs.transform_quantity = internal.transform_quantity;
+  }
+  if (internal.custom_unit_amount) {
+    attrs.custom_unit_amount = internal.custom_unit_amount;
+  } else {
+    attrs.unit_amount = Number(getPriceUintAmountByCurrency(internal, currency));
+  }
+
+  // create stripe price
+  const price = await client.prices.create(attrs);
+  await internal.update({ metadata: merge(internal.metadata || {}, { stripe_id: price.id }) });
+  logger.info('price created on stripe', { local: internal.id, remote: price.id });
+
+  // update product default price
+  if (!product.default_price) {
+    await client.products.update(product.id, { default_price: price.id });
+  }
+
+  return price;
+}
+
+export async function ensureStripeCustomer(internal: Customer, method: PaymentMethod) {
+  const client = method.getStripe();
+  const result = await client.customers.search({ query: `metadata['did']:'${internal.did}'` });
+  if (result.data.length > 0) {
+    return result.data[0] as any;
+  }
+
+  const customer = await client.customers.create({
+    name: internal.name,
+    email: internal.email,
+    phone: internal.phone,
+    invoice_prefix: internal.invoice_prefix,
+    metadata: {
+      appPid: env.appPid,
+      id: internal.id,
+      did: internal.did,
+    },
+  });
+
+  await internal.update({ metadata: merge(internal.metadata || {}, { stripe_id: customer.id }) });
+  logger.info('customer created on stripe', { local: internal.id, remote: customer.id });
+
+  return customer;
+}
+
+export async function ensureStripePaymentCustomer(internal: any, method: PaymentMethod) {
+  const client = method.getStripe();
+  let customer = null;
+  if (internal.payment_details?.stripe?.customer_id) {
+    customer = await client.customers.retrieve(internal.payment_details.stripe.customer_id);
+  } else {
+    const local = await Customer.findByPk(internal.customer_id);
+    customer = await ensureStripeCustomer(local as Customer, method);
+  }
+
+  return customer;
+}
+
+export async function ensureStripePaymentIntent(
+  internal: PaymentIntent,
+  method: PaymentMethod,
+  currency: PaymentCurrency
+) {
+  const client = method.getStripe();
+
+  let stripeIntent = null;
+  if (internal.payment_details?.stripe?.payment_intent_id) {
+    stripeIntent = await client.paymentIntents.retrieve(internal.payment_details.stripe.payment_intent_id);
+    // FIXME: update?
+  } else {
+    const customer = await ensureStripePaymentCustomer(internal, method);
+    stripeIntent = await client.paymentIntents.create({
+      amount: Number(internal.amount),
+      currency: currency.symbol.toLowerCase(),
+      customer: customer.id,
+      automatic_payment_methods: {
+        enabled: true,
+        allow_redirects: 'never',
+      },
+      statement_descriptor: internal.statement_descriptor,
+      metadata: {
+        appPid: env.appPid,
+        id: internal.id,
+      },
+    });
+    logger.info('stripe payment intent created', { local: internal.id, remote: stripeIntent.id });
+
+    await internal.update({
+      payment_details: {
+        stripe: {
+          customer_id: customer.id,
+          payment_intent_id: stripeIntent.id,
+        },
+      },
+    });
+  }
+
+  return stripeIntent;
+}
+
+export async function ensureStripeSubscription(
+  internal: Subscription,
+  method: PaymentMethod,
+  currency: PaymentCurrency,
+  items: TLineItemExpanded[],
+  trialInDays: number = 0
+) {
+  const client = method.getStripe();
+
+  let stripeSubscription: any = null;
+  if (internal.payment_details?.stripe?.subscription_id) {
+    stripeSubscription = await client.subscriptions.retrieve(internal.payment_details.stripe.subscription_id, {
+      expand: ['latest_invoice.payment_intent', 'pending_setup_intent'],
+    });
+    // FIXME: update?
+  } else {
+    const customer = await ensureStripePaymentCustomer(internal, method);
+    const prices = await Promise.all(
+      items.map(async (x: any) => {
+        x.stripePrice = await ensureStripePrice(x.price as any, method, currency);
+        return x;
+      })
+    );
+
+    const recurringItems = prices
+      .filter((x) => x.price.type === 'recurring')
+      .map((x) => {
+        if (x.price.recurring?.usage_type === 'metered') {
+          return { price: x.stripePrice.id };
+        }
+        return { price: x.stripePrice.id, quantity: x.quantity };
+      });
+
+    const onetimeItems = prices
+      .filter((x) => x.price.type !== 'recurring')
+      .map((x) => ({ price: x.stripePrice.id, quantity: x.quantity }));
+
+    stripeSubscription = await client.subscriptions.create({
+      currency: currency.symbol.toLowerCase(),
+      customer: customer.id,
+      items: recurringItems,
+      add_invoice_items: onetimeItems,
+      trial_period_days: trialInDays,
+      payment_behavior: 'default_incomplete',
+      payment_settings: { save_default_payment_method: 'on_subscription' },
+      metadata: {
+        appPid: env.appPid,
+        id: internal.id,
+      },
+      expand: ['latest_invoice.payment_intent', 'pending_setup_intent'],
+    });
+    logger.info('stripe subscription created', { local: internal.id, remote: stripeSubscription.id });
+
+    await Promise.all(
+      stripeSubscription.items.data.map(async (x: any) => {
+        const item = prices.find((y) => y.stripePrice.id === x.price.id);
+        let exist = await SubscriptionItem.findOne({
+          where: { price_id: item.price_id, subscription_id: internal.id },
+        });
+        if (exist) {
+          await exist.update({ metadata: { stripe_id: x.id, stripe_subscription_id: stripeSubscription.id } });
+          await client.subscriptionItems.update(x.id, { metadata: { appPid: env.appPid, id: exist.id } });
+          logger.info('stripe subscription items related', { local: exist.id, remote: x.id });
+        } else {
+          exist = await SubscriptionItem.create({
+            livemode: stripeSubscription.livemode,
+            price_id: item.price.id,
+            quantity: x.quantity,
+            subscription_id: internal.id,
+            billing_thresholds: x.billing_threshold,
+            metadata: {
+              stripe_id: x.id,
+              stripe_subscription_id: stripeSubscription.id,
+            },
+          });
+          await client.subscriptionItems.update(x.id, { metadata: { appPid: env.appPid, id: exist.id } });
+          logger.info('stripe subscription items mirrored', { local: exist.id, remote: x.id });
+        }
+      })
+    );
+
+    await internal.update({
+      payment_details: {
+        stripe: {
+          customer_id: customer.id,
+          subscription_id: stripeSubscription.id,
+          setup_intent_id: stripeSubscription.pending_setup_intent?.id,
+        },
+      },
+    });
+  }
+
+  return stripeSubscription;
+}
+
+export async function forwardUsageRecordToStripe(
+  subscriptionItem: SubscriptionItem,
+  updates: { quantity: number; timestamp: number; action: string }
+) {
+  if (!subscriptionItem.metadata?.stripe_id) {
+    logger.info('skip usage record forwarded to stripe because no relation', {
+      subscriptionItemId: subscriptionItem.id,
+      updates,
+    });
+    return null;
+  }
+
+  const subscription = await Subscription.findByPk(subscriptionItem.subscription_id);
+  if (!subscription) {
+    return null;
+  }
+
+  const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+  if (!method) {
+    return null;
+  }
+
+  const client = method.getStripe();
+  const result = await client.subscriptionItems.createUsageRecord(subscriptionItem.metadata.stripe_id, {
+    quantity: updates.quantity,
+    timestamp: updates.timestamp,
+    // @ts-ignore
+    action: subscription.billing_thresholds?.amount_gte ? 'increment' : updates.action,
+  });
+
+  logger.info('usage record forwarded to stripe', { subscriptionItemId: subscriptionItem.id, result });
+
+  return result;
+}

package/api/src/integrations/stripe/setup.ts

@@ -0,0 +1,50 @@
+/* eslint-disable no-await-in-loop */
+
+import env from '@blocklet/sdk/lib/env';
+
+import logger from '../../libs/logger';
+import { STRIPE_API_VERSION, STRIPE_ENDPOINT, STRIPE_EVENTS } from '../../libs/util';
+import { PaymentMethod } from '../../store/models';
+
+// register stripe webhooks on start/create if there are any stripe payment methods
+export async function ensureWebhookRegistered() {
+  const stripeMethods = await PaymentMethod.findAll({ where: { type: 'stripe' } });
+  for (const method of stripeMethods) {
+    const settings = PaymentMethod.decryptSettings(method.settings);
+    if (!settings.stripe) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    const stripe = method.getStripe();
+    const { data } = await stripe.webhookEndpoints.list({ limit: 100 });
+
+    const exist = data.find((webhook) => webhook.metadata?.appPid === env.appPid);
+    if (exist) {
+      await stripe.webhookEndpoints.update(exist.id, {
+        url: STRIPE_ENDPOINT,
+        description: env.appName,
+        enabled_events: STRIPE_EVENTS,
+        disabled: false,
+      });
+      logger.info('stripe webhook updated');
+    } else {
+      const result = await stripe.webhookEndpoints.create({
+        url: STRIPE_ENDPOINT,
+        description: env.appName,
+        enabled_events: STRIPE_EVENTS,
+        api_version: STRIPE_API_VERSION,
+        metadata: {
+          appPid: env.appPid,
+        },
+      });
+      logger.info('stripe webhook created');
+
+      if (result.secret) {
+        settings.stripe.webhook_signing_secret = result.secret;
+        await method.update({ settings: PaymentMethod.encryptSettings(settings) });
+        logger.info('stripe webhook signing secret updated');
+      }
+    }
+  }
+}

package/api/src/jobs/invoice.ts

@@ -3,6 +3,7 @@ import { Op } from 'sequelize';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
+import { PaymentMethod } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Invoice } from '../store/models/invoice';
 import { PaymentIntent } from '../store/models/payment-intent';
@@ -33,6 +34,12 @@ export const handleInvoice = async (job: InvoiceJob) => {
     return;
   }
 
+  const supportAutoCharge = await PaymentMethod.supportAutoCharge(invoice.default_payment_method_id);
+  if (supportAutoCharge === false) {
+    logger.warn(`Invoice does not support auto charge: ${job.invoiceId}`);
+    return;
+  }
+
   // no payment required
   if (invoice.total === '0') {
     logger.warn(`Invoice does not require payment: ${job.invoiceId}`);
@@ -136,6 +143,10 @@ export const startInvoiceQueue = async () => {
   });
 
   invoices.forEach(async (x) => {
+    const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
+    if (supportAutoCharge === false) {
+      return;
+    }
     const exist = await invoiceQueue.get(x.id);
     if (!exist) {
       invoiceQueue.push({ id: x.id, job: { invoiceId: x.id, retryOnError: true } });

package/api/src/jobs/payment.ts

@@ -38,9 +38,9 @@ export const handlePayment = async (job: PaymentJob) => {
     return;
   }
 
-  // FIXME: more methods supported here
-  if (paymentMethod.type !== 'arcblock') {
-    logger.warn(`Unexpected payment method type: ${paymentMethod.type}`);
+  const supportAutoCharge = await PaymentMethod.supportAutoCharge(paymentIntent.payment_method_id);
+  if (supportAutoCharge === false) {
+    logger.warn(`PaymentMethod does not support auto charge: ${paymentIntent.payment_method_id}`);
     return;
   }
 
@@ -88,8 +88,10 @@ export const handlePayment = async (job: PaymentJob) => {
       status: 'succeeded',
       amount_received: paymentIntent.amount,
       payment_details: {
-        tx_hash: txHash,
-        payer: paymentSettings?.payment_method_options.arcblock?.payer,
+        arcblock: {
+          tx_hash: txHash,
+          payer: paymentSettings?.payment_method_options.arcblock?.payer as string,
+        },
       },
     });
 
@@ -126,8 +128,10 @@ export const handlePayment = async (job: PaymentJob) => {
             status: 'complete',
             payment_status: 'paid',
             payment_details: {
-              tx_hash: txHash,
-              payer: paymentSettings?.payment_method_options.arcblock?.payer,
+              arcblock: {
+                tx_hash: txHash,
+                payer: paymentSettings?.payment_method_options.arcblock?.payer as string,
+              },
             },
           });
           logger.info(`CheckoutSession ${checkoutSession.id} updated on payment done ${invoice.id}`);
@@ -196,6 +200,10 @@ export const startPaymentQueue = async () => {
   });
 
   payments.forEach(async (x) => {
+    const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.payment_method_id);
+    if (supportAutoCharge === false) {
+      return;
+    }
     const exist = await paymentQueue.get(x.id);
     if (!exist) {
       paymentQueue.push({ id: x.id, job: { paymentIntentId: x.id } });

package/api/src/jobs/subscription.ts

@@ -5,7 +5,7 @@ import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
 import { getStatementDescriptor, getSubscriptionCycleAmount, getSubscriptionCycleSetup } from '../libs/session';
-import { UsageRecord } from '../store/models';
+import { PaymentCurrency, PaymentMethod, UsageRecord } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
 import { InvoiceItem } from '../store/models/invoice-item';
@@ -32,6 +32,11 @@ export const handleSubscription = async (job: SubscriptionJob) => {
     logger.warn(`Subscription status not expected: ${job.subscriptionId}`);
     return;
   }
+  const supportAutoCharge = await PaymentMethod.supportAutoCharge(subscription.default_payment_method_id);
+  if (supportAutoCharge === false) {
+    logger.warn(`Subscription does not support auto charge: ${job.subscriptionId}`);
+    return;
+  }
 
   const now = dayjs().unix();
 
@@ -86,6 +91,13 @@ export const handleSubscription = async (job: SubscriptionJob) => {
     return;
   }
 
+  // Do we still have the currency
+  const currency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!currency) {
+    logger.warn(`Currency ${subscription.currency_id} not found for subscription: ${subscription.id}`);
+    return;
+  }
+
   // get setup for next subscription period
   const previousPeriodEnd =
     subscription.status === 'trialing' ? subscription.trail_end : subscription.current_period_end;
@@ -154,7 +166,7 @@ export const handleSubscription = async (job: SubscriptionJob) => {
     })
   );
 
-  const amount = getSubscriptionCycleAmount(expandedItems);
+  const amount = getSubscriptionCycleAmount(expandedItems, currency);
 
   // create invoice
   const invoice = await Invoice.create({
@@ -285,6 +297,10 @@ export const startSubscriptionQueue = async () => {
   });
 
   subscriptions.forEach(async (x) => {
+    const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
+    if (supportAutoCharge === false) {
+      return;
+    }
     const exist = await subscriptionQueue.get(x.id);
     if (!exist) {
       subscriptionQueue.push({

package/api/src/libs/session.ts

@@ -1,9 +1,12 @@
 import { env } from '@blocklet/sdk/lib/config';
 import { BN } from '@ocap/util';
+import cloneDeep from 'lodash/cloneDeep';
+import isEqual from 'lodash/isEqual';
 
+import type { TPaymentCurrency, TPaymentMethodExpanded } from '../store/models';
 import type { Price, TPrice } from '../store/models/price';
 import type { Product } from '../store/models/product';
-import type { LineItem, PriceRecurring } from '../store/models/types';
+import type { LineItem, PriceCurrency, PriceRecurring } from '../store/models/types';
 import dayjs from './dayjs';
 
 export type TLineItemExpanded = LineItem & { price: TPrice };
@@ -35,8 +38,26 @@ export function getCheckoutMode(items: TLineItemExpanded[] = []) {
   return 'payment';
 }
 
+export function getPriceUintAmountByCurrency(price: TPrice, currency: TPaymentCurrency) {
+  const options = getPriceCurrencyOptions(price);
+  const option = options.find((x) => x.currency_id === currency.id);
+  if (option) {
+    return option.unit_amount;
+  }
+
+  return price.unit_amount;
+}
+
+export function getPriceCurrencyOptions(price: TPrice): PriceCurrency[] {
+  if (Array.isArray(price.currency_options)) {
+    return price.currency_options;
+  }
+
+  return [{ currency_id: price.currency_id, unit_amount: price.unit_amount, tiers: null, custom_unit_amount: null }];
+}
+
 // FIXME: apply coupon for discounts
-export function getCheckoutAmount(items: TLineItemExpanded[] = [], includeFreeTrial = false) {
+export function getCheckoutAmount(items: TLineItemExpanded[], currency: TPaymentCurrency, includeFreeTrial = false) {
   const subtotal = items
     .reduce((acc, x) => {
       if (x.price.type === 'recurring') {
@@ -47,7 +68,7 @@ export function getCheckoutAmount(items: TLineItemExpanded[] = [], includeFreeTr
           return acc;
         }
       }
-      return acc.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+      return acc.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
     }, new BN(0))
     .toString();
 
@@ -61,7 +82,7 @@ export function getCheckoutAmount(items: TLineItemExpanded[] = [], includeFreeTr
           return acc;
         }
       }
-      return acc.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+      return acc.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
     }, new BN(0))
     .toString();
 
@@ -89,7 +110,7 @@ export function getRecurringPeriod(recurring: PriceRecurring) {
   }
 }
 
-export function getSubscriptionCreateSetup(items: TLineItemExpanded[], trialInDays = 0) {
+export function getSubscriptionCreateSetup(items: TLineItemExpanded[], currency: TPaymentCurrency, trialInDays = 0) {
   let setup = new BN(0);
   let subscription = new BN(0);
 
@@ -97,7 +118,7 @@ export function getSubscriptionCreateSetup(items: TLineItemExpanded[], trialInDa
     setup = setup.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
     if (x.price.type === 'recurring') {
       if (trialInDays === 0) {
-        subscription = setup.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+        subscription = setup.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
       }
     }
   });
@@ -142,11 +163,11 @@ export function getSubscriptionCycleSetup(recurring: PriceRecurring, previousPer
   };
 }
 
-export function getSubscriptionCycleAmount(items: TLineItemExpanded[]) {
+export function getSubscriptionCycleAmount(items: TLineItemExpanded[], currency: TPaymentCurrency) {
   let amount = new BN(0);
 
   items.forEach((x) => {
-    amount = amount.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
+    amount = amount.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
   });
 
   return {
@@ -162,3 +183,78 @@ export function expandLineItems(items: any[], products: Product[], prices: Price
 
   return items;
 }
+
+export function filterCurrencies(method: TPaymentMethodExpanded, hasSelected: (currency: TPaymentCurrency) => boolean) {
+  method.payment_currencies = method.payment_currencies.filter((x) => hasSelected(x));
+  return method;
+}
+
+export function getSupportedPaymentMethods(
+  methods: TPaymentMethodExpanded[],
+  hasSelected: (currency: TPaymentCurrency) => boolean
+) {
+  const filtered = cloneDeep(methods).map((x) => filterCurrencies(x, hasSelected));
+  return filtered.filter((x) => x.payment_currencies.length);
+}
+
+export function getSupportedPaymentCurrencies(items: TLineItemExpanded[]) {
+  const currencies = items.reduce((acc: string[], x: any) => {
+    return acc.concat(getPriceCurrencyOptions(x.price).map((c: any) => c.currency_id));
+  }, []);
+  return Array.from(new Set(currencies));
+}
+
+export function isLineItemCurrencyAligned(list: TLineItemExpanded[], index: number) {
+  const prices = list.map((x) => x.price);
+
+  const current = getPriceCurrencyOptions(prices[index] as TPrice)
+    .map((x) => x.currency_id)
+    .sort();
+
+  for (let i = 0; i < index; i++) {
+    const previous = getPriceCurrencyOptions(prices[i] as TPrice)
+      .map((x) => x.currency_id)
+      .sort();
+    if (isEqual(current, previous) === false) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function isLineItemRecurringAligned(list: TLineItemExpanded[], index: number) {
+  const prices = list.map((x) => x.price);
+
+  if (prices[index]?.type !== 'recurring') {
+    return true;
+  }
+
+  const recurring = prices.slice(0, index).find((x) => x?.type === 'recurring')?.recurring;
+  if (!recurring) {
+    return true;
+  }
+
+  return prices.slice(0, index + 1).every((x: any) => {
+    if (x.type !== 'recurring') {
+      return true;
+    }
+
+    // If the interval and interval_count are different, the recurring is not aligned
+    if (recurring?.interval !== x.recurring?.interval || recurring?.interval_count !== x.recurring?.interval_count) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+export function isLineItemAligned(list: TLineItemExpanded[], index: number) {
+  const currency = isLineItemCurrencyAligned(list, index);
+  const recurring = isLineItemRecurringAligned(list, index);
+  return {
+    currency,
+    recurring,
+    aligned: currency && recurring,
+  };
+}