payment-kit 1.13.210 → 1.13.211

package/api/src/libs/api.ts

@@ -103,7 +103,7 @@ export const getWhereFromKvQuery = (query?: string) => {
   return out;
 };
 
-export function createListParamSchema<T>(schema: any) {
+export function createListParamSchema<T>(schema: any, pageSize: number = 20) {
   return Joi.object<T & { page: number; pageSize: number; livemode?: boolean; q?: string; o?: string }>({
     // prettier-ignore
     page: Joi.number()
@@ -118,7 +118,7 @@ export function createListParamSchema<T>(schema: any) {
 
     pageSize: Joi.number()
       .integer()
-      .default(20)
+      .default(pageSize)
       .custom((value) => {
         if (value > 100) {
           return 100;

package/api/src/libs/session.ts

@@ -1,4 +1,5 @@
 import { env } from '@blocklet/sdk/lib/config';
+import type { TransactionInput } from '@ocap/client';
 import { BN } from '@ocap/util';
 import cloneDeep from 'lodash/cloneDeep';
 import isEqual from 'lodash/isEqual';
@@ -6,7 +7,8 @@ import isEqual from 'lodash/isEqual';
 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 { PriceCurrency, PriceRecurring } from '../store/models/types';
+import type { PaymentBeneficiary, PriceCurrency, PriceRecurring } from '../store/models/types';
+import { wallet } from './auth';
 
 export function getStatementDescriptor(items: any[]) {
   for (const item of items) {
@@ -39,10 +41,16 @@ export function getPriceUintAmountByCurrency(price: TPrice, currencyId: string)
   const options = getPriceCurrencyOptions(price);
   const option = options.find((x) => x.currency_id === currencyId);
   if (option) {
+    if (option.custom_unit_amount) {
+      return option.custom_unit_amount.preset || option.custom_unit_amount.presets[0];
+    }
     return option.unit_amount;
   }
 
   if (price.currency_id === currencyId) {
+    if (price.custom_unit_amount) {
+      return price.custom_unit_amount.preset || price.custom_unit_amount.presets[0];
+    }
     return price.unit_amount;
   }
 
@@ -54,18 +62,40 @@ export function getPriceCurrencyOptions(price: TPrice): PriceCurrency[] {
     return price.currency_options;
   }
 
-  return [{ currency_id: price.currency_id, unit_amount: price.unit_amount, tiers: null, custom_unit_amount: null }];
+  return [
+    {
+      currency_id: price.currency_id,
+      unit_amount: price.unit_amount,
+      custom_unit_amount: price.custom_unit_amount || null,
+      tiers: null,
+    },
+  ];
 }
 
 // FIXME: apply coupon for discounts
 export function getCheckoutAmount(items: TLineItemExpanded[], currencyId: string, trialing = false) {
   let renew = new BN(0);
 
+  if (items.find((x) => (x.upsell_price || x.price).custom_unit_amount) && items.length > 1) {
+    throw new Error('Multiple items with custom unit amount are not supported');
+  }
+
   const total = items
     .reduce((acc, x) => {
+      if (x.custom_amount) {
+        return acc.add(new BN(x.custom_amount));
+      }
+
       const price = x.upsell_price || x.price;
+      const unitPrice = getPriceUintAmountByCurrency(price, currencyId);
+      if (price.custom_unit_amount) {
+        if (unitPrice) {
+          return acc.add(new BN(unitPrice).mul(new BN(x.quantity)));
+        }
+      }
+
       if (price?.type === 'recurring') {
-        renew = renew.add(new BN(getPriceUintAmountByCurrency(price, currencyId)).mul(new BN(x.quantity)));
+        renew = renew.add(new BN(unitPrice).mul(new BN(x.quantity)));
 
         if (trialing) {
           return acc;
@@ -74,7 +104,8 @@ export function getCheckoutAmount(items: TLineItemExpanded[], currencyId: string
           return acc;
         }
       }
-      return acc.add(new BN(getPriceUintAmountByCurrency(price, currencyId)).mul(new BN(x.quantity)));
+
+      return acc.add(new BN(unitPrice).mul(new BN(x.quantity)));
     }, new BN(0))
     .toString();
 
@@ -267,3 +298,58 @@ export function getBillingThreshold(config: Record<string, any> = {}) {
 
   return 0;
 }
+
+export function canPayWithDelegation(beneficiaries: PaymentBeneficiary[]) {
+  return beneficiaries.length === 0 || beneficiaries.every((x) => x.address === wallet.address);
+}
+
+export function createPaymentBeneficiaries(total: string, beneficiaries: PaymentBeneficiary[]) {
+  if (beneficiaries.length) {
+    const shares = beneficiaries.reduce((acc, x) => acc + parseInt(x.share, 10), 0);
+    const result: PaymentBeneficiary[] = [];
+    beneficiaries.forEach((x, i) => {
+      let share = new BN(total).div(new BN(shares)).mul(new BN(x.share)).toString();
+      if (i === beneficiaries.length - 1) {
+        share = result.reduce((acc, d) => acc.sub(new BN(d.share)), new BN(total)).toString();
+      }
+
+      result.push({ ...x, share });
+    });
+
+    return result;
+  }
+
+  return [];
+}
+
+export function createPaymentOutput(
+  total: string,
+  contract: string,
+  beneficiaries: PaymentBeneficiary[]
+): TransactionInput[] {
+  if (beneficiaries.length) {
+    return beneficiaries.map((x) => ({
+      owner: x.address,
+      assets: [],
+      tokens: [
+        {
+          address: contract,
+          value: x.share,
+        },
+      ],
+    }));
+  }
+
+  return [
+    {
+      owner: wallet.address,
+      assets: [],
+      tokens: [
+        {
+          address: contract,
+          value: total,
+        },
+      ],
+    },
+  ];
+}

package/api/src/queues/payment.ts

@@ -2,7 +2,7 @@ import isEmpty from 'lodash/isEmpty';
 
 import { ensureStakedForGas } from '../integrations/blockchain/stake';
 import { createEvent } from '../libs/audit';
-import { wallet } from '../libs/auth';
+import { blocklet, wallet } from '../libs/auth';
 import dayjs from '../libs/dayjs';
 import CustomError from '../libs/error';
 import { events } from '../libs/event';
@@ -25,6 +25,7 @@ import { Invoice } from '../store/models/invoice';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { PaymentIntent } from '../store/models/payment-intent';
 import { PaymentMethod } from '../store/models/payment-method';
+import { Payout } from '../store/models/payout';
 import { Price } from '../store/models/price';
 import { Subscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
@@ -37,6 +38,65 @@ type PaymentJob = {
 };
 
 export const handlePaymentSucceed = async (paymentIntent: PaymentIntent) => {
+  if (paymentIntent.beneficiaries?.length) {
+    Promise.all(
+      paymentIntent.beneficiaries.map(async (x) => {
+        let customer = await Customer.findByPkOrDid(x.address);
+        if (!customer) {
+          const { user } = await blocklet.getUser(x.address);
+          if (user) {
+            customer = await Customer.create({
+              livemode: paymentIntent.livemode,
+              did: user.did,
+              name: user.fullName,
+              email: user.email,
+              phone: '',
+              address: {},
+              description: user.remark,
+              metadata: {},
+              balance: '0',
+              next_invoice_sequence: 1,
+              delinquent: false,
+              invoice_prefix: Customer.getInvoicePrefix(),
+            });
+            logger.info('Customer created on payout record', {
+              paymentIntent: paymentIntent.id,
+              address: x.address,
+              customer: customer.id,
+            });
+          }
+        }
+
+        const payout = new Payout({
+          livemode: paymentIntent.livemode,
+          automatic: true,
+          description: paymentIntent.description,
+          amount: x.share,
+          destination: x.address,
+          payment_details: paymentIntent.payment_details,
+          payment_intent_id: paymentIntent.id,
+          customer_id: customer?.id || '',
+          currency_id: paymentIntent.currency_id,
+          payment_method_id: paymentIntent.payment_method_id,
+          status: 'paid',
+          attempt_count: 0,
+          attempted: false,
+          next_attempt: 0,
+          last_attempt_error: null,
+          metadata: {},
+        });
+        return payout.save();
+      })
+    )
+      .then(() => logger.info('Payout records created from payment done', { paymentIntent: paymentIntent.id }))
+      .catch((err) =>
+        logger.error('Payout records creation failed from payment done', {
+          paymentIntent: paymentIntent.id,
+          error: err,
+        })
+      );
+  }
+
   let invoice;
   if (paymentIntent.invoice_id) {
     invoice = await Invoice.findByPk(paymentIntent.invoice_id);

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

@@ -21,7 +21,9 @@ import logger from '../libs/logger';
 import { isCreditSufficientForPayment, isDelegationSufficientForPayment } from '../libs/payment';
 import { authenticate } from '../libs/security';
 import {
+  canPayWithDelegation,
   canUpsell,
+  createPaymentBeneficiaries,
   expandLineItems,
   getBillingThreshold,
   getCheckoutAmount,
@@ -38,10 +40,10 @@ import {
   getDaysUntilDue,
   getSubscriptionCreateSetup,
 } from '../libs/subscription';
-import { CHECKOUT_SESSION_TTL, createCodeGenerator, formatMetadata, getDataObjectFromQuery } from '../libs/util';
+import { CHECKOUT_SESSION_TTL, formatMetadata, getDataObjectFromQuery } from '../libs/util';
 import { invoiceQueue } from '../queues/invoice';
 import { paymentQueue } from '../queues/payment';
-import type { TPriceExpanded, TProductExpanded } from '../store/models';
+import type { LineItem, TPriceExpanded, TProductExpanded } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
 import { PaymentCurrency } from '../store/models/payment-currency';
@@ -55,8 +57,6 @@ import { Subscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
 import { ensureInvoiceForCheckout } from './connect/shared';
 
-const getInvoicePrefix = createCodeGenerator('', 8);
-
 const router = Router();
 
 const user = userMiddleware();
@@ -306,6 +306,9 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
     }
 
     const items = await Price.expand(link.line_items, { upsell: true });
+    if (items.find((x) => (x.upsell_price || x.price).custom_unit_amount) && items.length > 1) {
+      throw new Error('Multiple items with custom unit amount are not supported in checkout session');
+    }
 
     const raw: Partial<CheckoutSession> = await formatCheckoutSession(link, false);
     raw.livemode = link.livemode;
@@ -416,7 +419,6 @@ router.get('/retrieve/:id', user, async (req, res) => {
   // check payment intent
   const paymentIntent = doc.payment_intent_id ? await PaymentIntent.findByPk(doc.payment_intent_id) : null;
 
-  // FIXME: possible sensitive data leak
   res.json({
     checkoutSession: doc.toJSON(),
     paymentMethods: await getPaymentMethods(doc),
@@ -478,6 +480,9 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         amount_tax: amount.tax,
       },
     });
+    if (checkoutSession.mode === 'payment' && amount.total <= 0) {
+      return res.status(400).json({ error: 'Payment amount should be greater than 0' });
+    }
 
     // ensure customer created or updated
     let customer = await Customer.findOne({ where: { did: req.user.did } });
@@ -494,7 +499,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         balance: '0',
         next_invoice_sequence: 1,
         delinquent: false,
-        invoice_prefix: getInvoicePrefix(),
+        invoice_prefix: Customer.getInvoicePrefix(),
       });
       logger.info('customer created on checkout session submit', { did: req.user.did, id: customer.id });
     } else {
@@ -508,7 +513,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         updates.address = req.body.billing_address;
       }
       if (!customer.invoice_prefix) {
-        updates.invoice_prefix = getInvoicePrefix();
+        updates.invoice_prefix = Customer.getInvoicePrefix();
       }
 
       await customer.update(updates);
@@ -526,6 +531,10 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
     // payment intent is only created when checkout session is in payment mode
     let paymentIntent: PaymentIntent | null = null;
     if (checkoutSession.mode === 'payment') {
+      const paymentLink = checkoutSession.payment_link_id
+        ? await PaymentLink.findByPk(checkoutSession.payment_link_id)
+        : null;
+
       if (checkoutSession.payment_intent_id) {
         paymentIntent = await PaymentIntent.findByPk(checkoutSession.payment_intent_id);
       }
@@ -550,6 +559,10 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
           payment_method_id: paymentMethod.id,
           receipt_email: customer.email,
           last_payment_error: null,
+          beneficiaries: createPaymentBeneficiaries(
+            checkoutSession.amount_total,
+            paymentLink?.donation_settings?.beneficiaries || []
+          ),
         });
         logger.info('payment intent for checkout session reset', {
           session: checkoutSession.id,
@@ -574,6 +587,10 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
             checkoutSession.payment_intent_data?.statement_descriptor || getStatementDescriptor(lineItems),
           statement_descriptor_suffix: '',
           setup_future_usage: 'on_session',
+          beneficiaries: createPaymentBeneficiaries(
+            checkoutSession.amount_total,
+            paymentLink?.donation_settings?.beneficiaries || []
+          ),
           metadata: checkoutSession.payment_intent_data?.metadata || checkoutSession.metadata,
         });
         logger.info('paymentIntent created on checkout session submit', {
@@ -754,7 +771,8 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       amount: fastCheckoutAmount,
     });
 
-    if (checkoutSession.mode === 'payment' && paymentIntent) {
+    const canFastPay = canPayWithDelegation(paymentIntent?.beneficiaries || []);
+    if (checkoutSession.mode === 'payment' && paymentIntent && canFastPay) {
       if (balance.sufficient) {
         logger.info(`CheckoutSession ${checkoutSession.id} will pay from balance ${paymentIntent?.id}`);
       }
@@ -828,8 +846,8 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       subscription,
       checkoutSession,
       customer,
-      delegation: checkoutSession.mode === 'payment' ? delegation : null,
-      balance: checkoutSession.mode === 'payment' ? balance : null,
+      delegation: checkoutSession.mode === 'payment' && canFastPay ? delegation : null,
+      balance: checkoutSession.mode === 'payment' && canFastPay ? balance : null,
     });
   } catch (err) {
     console.error(err);
@@ -1022,6 +1040,39 @@ router.delete('/:id/cross-sell', user, ensureCheckoutSessionOpen, async (req, re
   }
 });
 
+// change payment amount
+router.put('/:id/amount', user, ensureCheckoutSessionOpen, async (req, res) => {
+  try {
+    const checkoutSession = req.doc as CheckoutSession;
+    const items = await Price.expand(checkoutSession.line_items);
+    const item = items.find((x) => x.price_id === req.body.priceId);
+    if (!item) {
+      return res.status(400).json({ error: 'LineItem not in checkout session' });
+    }
+    if (!item.price.custom_unit_amount) {
+      return res.status(400).json({ error: 'PriceItem not customizable for checkout session' });
+    }
+    // TODO: add more validation for amount
+
+    // update line items
+    const newItems = cloneDeep(checkoutSession.line_items);
+    const newItem = newItems.find((x) => x.price_id === req.body.priceId);
+    if (newItem) {
+      newItem.custom_amount = req.body.amount;
+    }
+    await checkoutSession.update({ line_items: newItems.map((x) => omit(x, ['price'])) as LineItem[] });
+    logger.info('CheckoutSession updated on amount', { id: req.params.id, ...req.body, newItem });
+
+    // recalculate amount
+    await checkoutSession.update(await getCheckoutSessionAmounts(checkoutSession));
+
+    res.json({ ...checkoutSession.toJSON(), line_items: await Price.expand(newItems) });
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
 const schema = Joi.object<{
   page: number;
   pageSize: number;

package/api/src/routes/connect/collect.ts

@@ -3,6 +3,7 @@ import { fromAddress } from '@ocap/wallet';
 
 import type { CallbackArgs } from '../../libs/auth';
 import { wallet } from '../../libs/auth';
+import logger from '../../libs/logger';
 import { getGasPayerExtra } from '../../libs/payment';
 import { getTxMetadata } from '../../libs/util';
 import { invoiceQueue } from '../../queues/invoice';
@@ -75,51 +76,57 @@ export default {
     const { invoice, paymentIntent, paymentMethod } = await ensureInvoiceForCollect(invoiceId);
 
     if (paymentMethod.type === 'arcblock') {
-      await paymentIntent.update({ status: 'processing' });
-      const client = paymentMethod.getOcapClient();
-      const claim = claims.find((x) => x.type === 'prepareTx');
+      try {
+        await paymentIntent.update({ status: 'processing' });
+        const client = paymentMethod.getOcapClient();
+        const claim = claims.find((x) => x.type === 'prepareTx');
 
-      const tx: Partial<Transaction> = client.decodeTx(claim.finalTx);
-      if (claim.delegator && claim.from) {
-        tx.delegator = claim.delegator;
-        tx.from = claim.from;
-      }
+        const tx: Partial<Transaction> = client.decodeTx(claim.finalTx);
+        if (claim.delegator && claim.from) {
+          tx.delegator = claim.delegator;
+          tx.from = claim.from;
+        }
 
-      // @ts-ignore
-      const { buffer } = await client.encodeTransferV3Tx({ tx });
-      const txHash = await client.sendTransferV3Tx(
         // @ts-ignore
-        { tx, wallet: fromAddress(userDid) },
-        getGasPayerExtra(buffer)
-      );
+        const { buffer } = await client.encodeTransferV3Tx({ tx });
+        const txHash = await client.sendTransferV3Tx(
+          // @ts-ignore
+          { tx, wallet: fromAddress(userDid) },
+          getGasPayerExtra(buffer)
+        );
 
-      await paymentIntent.update({
-        status: 'succeeded',
-        amount_received: invoice.amount_due,
-        capture_method: 'manual',
-        last_payment_error: null,
-        payment_details: {
-          arcblock: {
-            tx_hash: txHash,
-            payer: userDid,
-            type: 'transfer',
+        await paymentIntent.update({
+          status: 'succeeded',
+          amount_received: invoice.amount_due,
+          capture_method: 'manual',
+          last_payment_error: null,
+          payment_details: {
+            arcblock: {
+              tx_hash: txHash,
+              payer: userDid,
+              type: 'transfer',
+            },
           },
-        },
-      });
+        });
 
-      await handlePaymentSucceed(paymentIntent);
+        await handlePaymentSucceed(paymentIntent);
 
-      // cleanup the queue
-      let exist = await paymentQueue.get(paymentIntent.id);
-      if (exist) {
-        await paymentQueue.delete(paymentIntent.id);
-      }
-      exist = await invoiceQueue.get(invoice.id);
-      if (exist) {
-        await invoiceQueue.delete(invoice.id);
-      }
+        // cleanup the queue
+        let exist = await paymentQueue.get(paymentIntent.id);
+        if (exist) {
+          await paymentQueue.delete(paymentIntent.id);
+        }
+        exist = await invoiceQueue.get(invoice.id);
+        if (exist) {
+          await invoiceQueue.delete(invoice.id);
+        }
 
-      return { hash: txHash };
+        return { hash: txHash };
+      } catch (err) {
+        logger.error('Failed to finalize collect', { paymentIntent: paymentIntent.id, error: err });
+        await paymentIntent.update({ status: 'requires_capture' });
+        return {};
+      }
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);

package/api/src/routes/connect/pay.ts

@@ -2,8 +2,9 @@ import type { Transaction, TransferV3Tx } from '@ocap/client';
 import { fromAddress } from '@ocap/wallet';
 
 import type { CallbackArgs } from '../../libs/auth';
-import { wallet } from '../../libs/auth';
+import logger from '../../libs/logger';
 import { getGasPayerExtra } from '../../libs/payment';
+import { createPaymentOutput } from '../../libs/session';
 import { getTxMetadata } from '../../libs/util';
 import { handlePaymentSucceed } from '../../queues/payment';
 import { ensureInvoiceForCheckout, ensurePaymentIntent, getAuthPrincipalClaim } from './shared';
@@ -28,7 +29,11 @@ export default {
       const tokens = [{ address: paymentCurrency.contract as string, value: paymentIntent.amount }];
       // @ts-ignore
       const itx: TransferV3Tx = {
-        outputs: [{ owner: wallet.address, tokens, assets: [] }],
+        outputs: createPaymentOutput(
+          paymentIntent.amount,
+          paymentCurrency.contract as string,
+          paymentIntent.beneficiaries || []
+        ),
         data: getTxMetadata({
           paymentIntentId: paymentIntent.id,
           checkoutSessionId,
@@ -64,40 +69,46 @@ export default {
     await ensureInvoiceForCheckout({ checkoutSession, customer, paymentIntent });
 
     if (paymentMethod.type === 'arcblock') {
-      await paymentIntent.update({ status: 'processing' });
-      const client = paymentMethod.getOcapClient();
-      const claim = claims.find((x) => x.type === 'prepareTx');
+      try {
+        await paymentIntent.update({ status: 'processing' });
+        const client = paymentMethod.getOcapClient();
+        const claim = claims.find((x) => x.type === 'prepareTx');
 
-      const tx: Partial<Transaction> = client.decodeTx(claim.finalTx);
-      if (claim.delegator && claim.from) {
-        tx.delegator = claim.delegator;
-        tx.from = claim.from;
-      }
+        const tx: Partial<Transaction> = client.decodeTx(claim.finalTx);
+        if (claim.delegator && claim.from) {
+          tx.delegator = claim.delegator;
+          tx.from = claim.from;
+        }
 
-      // @ts-ignore
-      const { buffer } = await client.encodeTransferV3Tx({ tx });
-      const txHash = await client.sendTransferV3Tx(
         // @ts-ignore
-        { tx, wallet: fromAddress(userDid) },
-        getGasPayerExtra(buffer)
-      );
+        const { buffer } = await client.encodeTransferV3Tx({ tx });
+        const txHash = await client.sendTransferV3Tx(
+          // @ts-ignore
+          { tx, wallet: fromAddress(userDid) },
+          getGasPayerExtra(buffer)
+        );
 
-      await paymentIntent.update({
-        status: 'succeeded',
-        amount_received: paymentIntent.amount,
-        last_payment_error: null,
-        payment_details: {
-          arcblock: {
-            tx_hash: txHash,
-            payer: userDid,
-            type: 'transfer',
+        await paymentIntent.update({
+          status: 'succeeded',
+          amount_received: paymentIntent.amount,
+          last_payment_error: null,
+          payment_details: {
+            arcblock: {
+              tx_hash: txHash,
+              payer: userDid,
+              type: 'transfer',
+            },
           },
-        },
-      });
+        });
 
-      await handlePaymentSucceed(paymentIntent);
+        await handlePaymentSucceed(paymentIntent);
 
-      return { hash: txHash };
+        return { hash: txHash };
+      } catch (err) {
+        logger.error('Failed to finalize paymentIntent', { paymentIntent: paymentIntent.id, error: err });
+        await paymentIntent.update({ status: 'requires_capture' });
+        return {};
+      }
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);