payment-kit 1.13.30 → 1.13.32

package/api/src/integrations/blockchain/nft.ts

@@ -118,7 +118,6 @@ export async function mintNftForCheckoutSession(id: string) {
       factoryState.name
     );
     logger.info('nft sent for checkoutSession', { id, nftOwner });
-    await checkoutSession.update({ nft_mint_status: 'sent' });
 
     return;
   }

package/api/src/integrations/blocklet/passport.ts

@@ -15,7 +15,7 @@ import {
 
 export async function checkPassportForPaymentLink(doc: PaymentLink) {
   // @ts-ignore
-  const items: TLineItemExpanded[] = await Price.expand(doc.line_items, true);
+  const items: TLineItemExpanded[] = await Price.expand(doc.line_items);
   const item = items.find((x) => x.price.product?.metadata?.passport);
   return item?.price.product?.metadata?.passport;
 }

package/api/src/integrations/stripe/handlers/invoice.ts

@@ -20,16 +20,57 @@ export async function handleStripeInvoicePaid(invoice: Invoice, event: TEventExp
   await invoice.update({
     status: 'paid',
     ...pick(event.data.object, [
-      'paid',
-      'paid_out_of_band',
       'amount_due',
       'amount_paid',
       'amount_remaining',
+      'last_finalization_error',
+      'paid_out_of_band',
+      'paid',
       'status_transitions',
+      'subtotal_excluding_tax',
+      'subtotal',
+      'tax',
+      'total_discount_amounts',
+      'total',
     ]),
   });
 }
 
+export async function syncStripeInvoice(invoice: Invoice) {
+  if (!invoice.metadata?.stripe_id) {
+    return;
+  }
+
+  const method = await PaymentMethod.findByPk(invoice.default_payment_method_id);
+  if (!method) {
+    return;
+  }
+
+  const client = await method.getStripeClient();
+  const stripeInvoice = await client.invoices.retrieve(invoice.metadata.stripe_id);
+  if (stripeInvoice) {
+    await invoice.update(
+      // @ts-ignore
+      pick(stripeInvoice, [
+        'amount_due',
+        'amount_paid',
+        'amount_remaining',
+        'last_finalization_error',
+        'paid_out_of_band',
+        'paid',
+        'status_transitions',
+        'status',
+        'subtotal_excluding_tax',
+        'subtotal',
+        'tax',
+        'total_discount_amounts',
+        'total',
+      ])
+    );
+    logger.info('stripe invoice synced', { locale: invoice.id, remote: stripeInvoice.id });
+  }
+}
+
 export async function ensureStripeInvoice(stripeInvoice: any, subscription: Subscription, client: Stripe) {
   const customer = await Customer.findByPk(subscription.customer_id);
   const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
@@ -76,6 +117,7 @@ export async function ensureStripeInvoice(stripeInvoice: any, subscription: Subs
       'tax',
       'total_discount_amounts',
       'total',
+      'last_finalization_error',
     ]),
 
     currency_id: subscription.currency_id,

package/api/src/integrations/stripe/handlers/payment-intent.ts

@@ -6,7 +6,7 @@ import type Stripe from 'stripe';
 
 import dayjs from '../../../libs/dayjs';
 import logger from '../../../libs/logger';
-import { CheckoutSession, Invoice, PaymentIntent, TEventExpanded } from '../../../store/models';
+import { CheckoutSession, Invoice, PaymentIntent, PaymentMethod, TEventExpanded } from '../../../store/models';
 import { handleStripeInvoiceCreated } from './invoice';
 
 export async function handleStripePaymentSucceed(paymentIntent: PaymentIntent, event?: TEventExpanded) {
@@ -46,6 +46,31 @@ export async function handleStripePaymentSucceed(paymentIntent: PaymentIntent, e
   }
 }
 
+export async function syncStripPayment(paymentIntent: PaymentIntent) {
+  if (!paymentIntent.metadata?.stripe_id) {
+    return;
+  }
+
+  const method = await PaymentMethod.findByPk(paymentIntent.payment_method_id);
+  if (!method) {
+    return;
+  }
+
+  const client = await method.getStripeClient();
+  const stripeIntent = await client.paymentIntents.retrieve(paymentIntent.metadata.stripe_id);
+  if (stripeIntent) {
+    // @ts-ignore
+    await paymentIntent.update({
+      amount: String(stripeIntent.amount),
+      amount_received: String(stripeIntent.amount_received),
+      amount_capturable: String(stripeIntent.amount_capturable),
+      amount_details: stripeIntent.amount_details as any,
+      ...pick(stripeIntent, ['status', 'confirmation_method', 'capture_method', 'last_payment_error']),
+    });
+    logger.info('stripe payment intent synced', { locale: paymentIntent.id, remote: stripeIntent.id });
+  }
+}
+
 export async function handleStripePaymentCreated(event: TEventExpanded, client: Stripe) {
   logger.info('possible payment intent from subscription', { id: event.id, type: event.type });
 
@@ -69,9 +94,9 @@ export async function handleStripePaymentCreated(event: TEventExpanded, client:
       payment_method_types: ['stripe'],
 
       amount: String(stripeIntent.amount),
-      amount_received: '0',
+      amount_received: String(stripeIntent.amount_received),
       amount_capturable: String(stripeIntent.amount_capturable),
-      amount_details: { tip: '0' },
+      amount_details: stripeIntent.amount_details,
 
       ...pick(stripeIntent, [
         'livemode',
@@ -83,6 +108,7 @@ export async function handleStripePaymentCreated(event: TEventExpanded, client:
         'statement_descriptor',
         'statement_descriptor_suffix',
         'setup_future_usage',
+        'last_payment_error',
       ]),
 
       metadata: {
@@ -113,11 +139,9 @@ export async function handlePaymentIntentEvent(event: TEventExpanded, client: St
   const localIntentId = event.data.object.metadata?.id;
   if (!localIntentId) {
     // We only handle payment_intents created from subscriptions
-    if (event.type === 'payment_intent.created') {
-      if (event.data.object.invoice) {
-        await handleStripePaymentCreated(event, client);
-        return;
-      }
+    if (event.data.object.invoice) {
+      await handleStripePaymentCreated(event, client);
+      return;
     }
 
     try {

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

@@ -205,7 +205,8 @@ export async function ensureStripeSubscription(
     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);
+        const price = x.upsell_price || x.price;
+        x.stripePrice = await ensureStripePrice(price as any, method, currency);
         return x;
       })
     );
@@ -213,7 +214,8 @@ export async function ensureStripeSubscription(
     const recurringItems = prices
       .filter((x) => x.price.type === 'recurring')
       .map((x) => {
-        if (x.price.recurring?.usage_type === 'metered') {
+        const price = x.upsell_price || x.price;
+        if (price.recurring?.usage_type === 'metered') {
           return { price: x.stripePrice.id };
         }
         return { price: x.stripePrice.id, quantity: x.quantity };
@@ -242,8 +244,9 @@ export async function ensureStripeSubscription(
     await Promise.all(
       stripeSubscription.items.data.map(async (x: any) => {
         const item = prices.find((y) => y.stripePrice.id === x.price.id);
+        const price = item.upsell_price || item.price; // local
         let exist = await SubscriptionItem.findOne({
-          where: { price_id: item.price_id, subscription_id: internal.id },
+          where: { price_id: price.id, subscription_id: internal.id },
         });
         if (exist) {
           await exist.update({ metadata: { stripe_id: x.id, stripe_subscription_id: stripeSubscription.id } });
@@ -252,7 +255,7 @@ export async function ensureStripeSubscription(
         } else {
           exist = await SubscriptionItem.create({
             livemode: stripeSubscription.livemode,
-            price_id: item.price.id,
+            price_id: price.id,
             quantity: x.quantity,
             subscription_id: internal.id,
             billing_thresholds: x.billing_threshold,

package/api/src/jobs/subscription.ts

@@ -134,7 +134,7 @@ export const handleSubscription = async (job: SubscriptionJob) => {
   const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
   let expandedItems = await Price.expand(
     subscriptionItems.map((x) => ({ id: x.id, price_id: x.price_id, quantity: x.quantity })),
-    true
+    { product: true }
   );
 
   // get usage summaries for this billing cycle

package/api/src/libs/payment.ts

@@ -31,13 +31,18 @@ export async function isDelegationSufficientForPayment(args: {
       return { sufficient: false, reason: 'NO_DELEGATION' };
     }
 
+    // have enough permissions
+    if (state.ops.some((x: any) => x.key === 'fg:t:transfer_v2') === false) {
+      return { sufficient: false, reason: 'NO_TRANSFER_PERMISSION' };
+    }
+
     // balance enough token for payment?
     const { tokens } = await client.getAccountTokens({ address: delegator, token: paymentCurrency.contract as string });
     const [token] = tokens;
     if (!token) {
       return { sufficient: false, reason: 'NO_TOKEN' };
     }
-    if (new BN(amount).gt(new BN(token.balance))) {
+    if (new BN(token.balance).lte(new BN(amount))) {
       return { sufficient: false, reason: 'NO_ENOUGH_TOKEN' };
     }
 

package/api/src/libs/session.ts

@@ -3,14 +3,12 @@ import { BN } from '@ocap/util';
 import cloneDeep from 'lodash/cloneDeep';
 import isEqual from 'lodash/isEqual';
 
-import type { TPaymentCurrency, TPaymentMethodExpanded } from '../store/models';
+import type { TLineItemExpanded, TPaymentCurrency, TPaymentMethodExpanded } from '../store/models';
 import type { Price, TPrice } from '../store/models/price';
 import type { Product } from '../store/models/product';
-import type { LineItem, PriceCurrency, PriceRecurring } from '../store/models/types';
+import type { PriceCurrency, PriceRecurring } from '../store/models/types';
 import dayjs from './dayjs';
 
-export type TLineItemExpanded = LineItem & { price: TPrice };
-
 export function getStatementDescriptor(items: any[]) {
   for (const item of items) {
     if (item.price?.product?.statement_descriptor) {
@@ -58,35 +56,26 @@ export function getPriceCurrencyOptions(price: TPrice): PriceCurrency[] {
 
 // FIXME: apply coupon for discounts
 export function getCheckoutAmount(items: TLineItemExpanded[], currency: TPaymentCurrency, includeFreeTrial = false) {
-  const subtotal = items
-    .reduce((acc, x) => {
-      if (x.price.type === 'recurring') {
-        if (includeFreeTrial) {
-          return acc;
-        }
-        if (x.price.recurring?.usage_type === 'metered') {
-          return acc;
-        }
-      }
-      return acc.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
-    }, new BN(0))
-    .toString();
+  let renew = new BN(0);
 
   const total = items
     .reduce((acc, x) => {
-      if (x.price.type === 'recurring') {
+      const price = x.upsell_price || x.price;
+      if (price.type === 'recurring') {
+        renew = renew.add(new BN(getPriceUintAmountByCurrency(price, currency)).mul(new BN(x.quantity)));
+
         if (includeFreeTrial) {
           return acc;
         }
-        if (x.price.recurring?.usage_type === 'metered') {
+        if (price.recurring?.usage_type === 'metered') {
           return acc;
         }
       }
-      return acc.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
+      return acc.add(new BN(getPriceUintAmountByCurrency(price, currency)).mul(new BN(x.quantity)));
     }, new BN(0))
     .toString();
 
-  return { subtotal, total, discount: '0', shipping: '0', tax: '0' };
+  return { subtotal: total, total, renew: renew.toString(), discount: '0', shipping: '0', tax: '0' };
 }
 
 export function getRecurringPeriod(recurring: PriceRecurring) {
@@ -115,15 +104,17 @@ export function getSubscriptionCreateSetup(items: TLineItemExpanded[], currency:
   let subscription = new BN(0);
 
   items.forEach((x) => {
-    setup = setup.add(new BN(x.price.unit_amount).mul(new BN(x.quantity)));
-    if (x.price.type === 'recurring') {
+    const price = x.upsell_price || x.price;
+    setup = setup.add(new BN(price.unit_amount).mul(new BN(x.quantity)));
+    if (price.type === 'recurring') {
       if (trialInDays === 0) {
-        subscription = setup.add(new BN(getPriceUintAmountByCurrency(x.price, currency)).mul(new BN(x.quantity)));
+        subscription = setup.add(new BN(getPriceUintAmountByCurrency(price, currency)).mul(new BN(x.quantity)));
       }
     }
   });
 
-  const recurring = items.find((x) => x.price.type === 'recurring')?.price.recurring as PriceRecurring;
+  const item = items.find((x) => x.price.type === 'recurring');
+  const recurring = (item?.upsell_price || item?.price)?.recurring as PriceRecurring;
   const cycle = getRecurringPeriod(recurring);
   const trial = trialInDays ? trialInDays * 24 * 60 * 60 * 1000 : 0;
 
@@ -205,7 +196,7 @@ export function getSupportedPaymentCurrencies(items: TLineItemExpanded[]) {
 }
 
 export function isLineItemCurrencyAligned(list: TLineItemExpanded[], index: number) {
-  const prices = list.map((x) => x.price);
+  const prices = list.map((x) => x.upsell_price || x.price);
 
   const current = getPriceCurrencyOptions(prices[index] as TPrice)
     .map((x) => x.currency_id)
@@ -224,7 +215,7 @@ export function isLineItemCurrencyAligned(list: TLineItemExpanded[], index: numb
 }
 
 export function isLineItemRecurringAligned(list: TLineItemExpanded[], index: number) {
-  const prices = list.map((x) => x.price);
+  const prices = list.map((x) => x.upsell_price || x.price);
 
   if (prices[index]?.type !== 'recurring') {
     return true;
@@ -258,3 +249,63 @@ export function isLineItemAligned(list: TLineItemExpanded[], index: number) {
     aligned: currency && recurring,
   };
 }
+
+// FIXME: upsell validate https://stripe.com/docs/payments/checkout/upsells
+export function canUpsell(from: TPrice, to: TPrice) {
+  if (from.id === to.id) {
+    return false;
+  }
+  if (from.product_id !== to.product_id) {
+    return false;
+  }
+  if (to.active === false) {
+    return false;
+  }
+  if (to.type !== 'recurring') {
+    return false;
+  }
+
+  // longer periods
+  const fromPeriod = getRecurringPeriod(from.recurring as PriceRecurring);
+  const toPeriod = getRecurringPeriod(to.recurring as PriceRecurring);
+  if (fromPeriod >= toPeriod) {
+    return false;
+  }
+
+  // and lower prices
+  const fromPrice = new BN(from.unit_amount).div(new BN(fromPeriod));
+  const toPrice = new BN(to.unit_amount).div(new BN(toPeriod));
+  if (fromPrice.lt(toPrice)) {
+    return false;
+  }
+
+  return true;
+}
+
+export function getFastCheckoutAmount(
+  items: TLineItemExpanded[],
+  mode: string,
+  currency: TPaymentCurrency,
+  includeFreeTrial = false,
+  minimumCycle = 2
+) {
+  if (minimumCycle < 1) {
+    // eslint-disable-next-line no-param-reassign
+    minimumCycle = 1;
+  }
+
+  const { total, renew } = getCheckoutAmount(items, currency, includeFreeTrial);
+  if (mode === 'payment') {
+    return total;
+  }
+
+  if (mode === 'setup') {
+    return new BN(renew).mul(new BN(minimumCycle)).toString();
+  }
+
+  if (mode === 'subscription') {
+    return new BN(total).add(new BN(renew).mul(new BN(minimumCycle - 1))).toString();
+  }
+
+  return '0';
+}

package/api/src/libs/util.ts

@@ -1,6 +1,7 @@
 import crypto from 'crypto';
 
 import { getUrl } from '@blocklet/sdk/lib/component';
+import env from '@blocklet/sdk/lib/env';
 import { customAlphabet } from 'nanoid';
 
 import dayjs from './dayjs';
@@ -142,3 +143,17 @@ export const getNextRetry = (retryCount: number) => {
 export const getWebhookJobId = (eventId: string, webhookId: string) => {
   return md5([eventId, webhookId].join('-'));
 };
+
+export function getTxMetadata(extra: Record<string, any> = {}): any {
+  return {
+    type: 'json',
+    value: {
+      paymentKit: {
+        // FIXME: this should be customizable
+        description: `Manage subscriptions and payments on ${env.appName}`,
+        customerPortal: getUrl('/customer'),
+        ...extra,
+      },
+    },
+  };
+}