payment-kit 1.22.32 → 1.23.1

package/api/src/queues/token-transfer.ts

@@ -0,0 +1,331 @@
+import { BN } from '@ocap/util';
+import logger from '../libs/logger';
+import createQueue from '../libs/queue';
+import { transferTokenFromCustomer, getCustomerTokenBalance } from '../integrations/arcblock/token';
+import { CreditTransaction, CreditGrant, Customer, MeterEvent, PaymentCurrency, Subscription } from '../store/models';
+
+type TokenTransferJob = {
+  creditTransactionId: string;
+  creditGrantId: string;
+  customerDid: string;
+  amount: string;
+  paymentCurrencyId: string;
+  meterEventId: string;
+  subscriptionId?: string;
+};
+
+type ValidationResult =
+  | { valid: false }
+  | {
+      valid: true;
+      creditTransaction: CreditTransaction;
+      creditGrant: CreditGrant;
+      customer: Customer;
+      paymentCurrency: PaymentCurrency;
+      meterEvent: MeterEvent;
+      subscription?: Subscription;
+    };
+
+/**
+ * Validate transfer job and fetch required data
+ */
+async function validateAndFetchData(job: TokenTransferJob): Promise<ValidationResult> {
+  const creditTransaction = await CreditTransaction.findByPk(job.creditTransactionId);
+  if (!creditTransaction) {
+    logger.warn('CreditTransaction not found', { creditTransactionId: job.creditTransactionId });
+    return { valid: false };
+  }
+
+  // Check if already transferred
+  if (creditTransaction.transfer_status === 'completed') {
+    logger.info('Token transfer already completed', { creditTransactionId: job.creditTransactionId });
+    return { valid: false };
+  }
+
+  const creditGrant = await CreditGrant.findByPk(job.creditGrantId);
+  if (!creditGrant) {
+    logger.warn('CreditGrant not found', { creditGrantId: job.creditGrantId });
+    return { valid: false };
+  }
+
+  const customer = await Customer.findByPkOrDid(job.customerDid);
+  if (!customer) {
+    logger.warn('Customer not found', { customerDid: job.customerDid });
+    return { valid: false };
+  }
+
+  const paymentCurrency = await PaymentCurrency.findByPk(job.paymentCurrencyId);
+  if (!paymentCurrency) {
+    logger.warn('PaymentCurrency not found', { paymentCurrencyId: job.paymentCurrencyId });
+    return { valid: false };
+  }
+
+  const meterEvent = await MeterEvent.findByPk(job.meterEventId);
+  if (!meterEvent) {
+    logger.warn('MeterEvent not found', { meterEventId: job.meterEventId });
+    return { valid: false };
+  }
+
+  let subscription: Subscription | undefined;
+  if (job.subscriptionId) {
+    subscription = (await Subscription.findByPk(job.subscriptionId)) || undefined;
+  }
+
+  return {
+    valid: true,
+    creditTransaction,
+    creditGrant,
+    customer,
+    paymentCurrency,
+    meterEvent,
+    subscription,
+  };
+}
+
+/**
+ * Handle token transfer job
+ */
+export async function handleTokenTransfer(job: TokenTransferJob): Promise<void> {
+  logger.info('Starting token transfer job', {
+    creditTransactionId: job.creditTransactionId,
+    creditGrantId: job.creditGrantId,
+    customerDid: job.customerDid,
+    amount: job.amount,
+  });
+
+  const validation = await validateAndFetchData(job);
+  if (!validation.valid) {
+    logger.warn('Token transfer validation failed, skipping', { job });
+    return;
+  }
+
+  const { creditTransaction, creditGrant, customer, paymentCurrency, meterEvent } = validation;
+
+  let txHash: string | null = null;
+  // Record partial transfer details when chain balance is insufficient
+  let transferResult: { expected: string; actual: string } | null = null;
+
+  try {
+    // Attempt token transfer
+    txHash = await transferTokenFromCustomer({
+      paymentCurrency,
+      customerDid: customer.did,
+      amount: job.amount,
+      data: {
+        reason: 'credit_consumption',
+        creditGrantId: creditGrant.id,
+        meterEventId: meterEvent.id,
+      },
+    });
+
+    logger.info('Token transfer completed successfully', {
+      creditTransactionId: creditTransaction.id,
+      txHash,
+      from: customer.did,
+      amount: job.amount,
+      currency: paymentCurrency.symbol,
+    });
+  } catch (error: any) {
+    const isInsufficientBalanceError =
+      error?.message?.includes('does not have enough token') || error?.message?.includes('INSUFFICIENT_TOKEN_BALANCE');
+
+    if (!isInsufficientBalanceError) {
+      logger.error('Token transfer failed', {
+        error,
+        creditTransactionId: creditTransaction.id,
+        customerDid: customer.did,
+        amount: job.amount,
+      });
+      throw error;
+    }
+
+    // Handle insufficient balance: transfer whatever we can and mark as completed
+    logger.warn('Insufficient chain balance detected', {
+      creditTransactionId: creditTransaction.id,
+      requestedAmount: job.amount,
+      error,
+    });
+
+    // Get actual chain balance
+    const chainBalance = await getCustomerTokenBalance(customer.did, paymentCurrency);
+    const chainBalanceBN = new BN(chainBalance);
+    const expectBalanceBN = new BN(job.amount);
+    const chainDebt = expectBalanceBN.sub(chainBalanceBN);
+    const transferAmount = BN.min(chainBalanceBN, expectBalanceBN);
+
+    // Record transfer result for metadata (only when partial)
+    if (chainDebt.gt(new BN(0))) {
+      transferResult = {
+        expected: job.amount,
+        actual: transferAmount.toString(),
+      };
+    }
+
+    if (chainBalanceBN.lt(expectBalanceBN)) {
+      logger.error('CRITICAL: Chain balance is less than requested amount', {
+        creditTransactionId: creditTransaction.id,
+        chainBalance: chainBalance.toString(),
+        requestedAmount: job.amount,
+        chainDebt: chainDebt.toString(),
+      });
+    }
+
+    // Transfer tokens if there is any balance
+    if (chainBalanceBN.gt(new BN(0))) {
+      txHash = await transferTokenFromCustomer({
+        paymentCurrency,
+        customerDid: customer.did,
+        amount: transferAmount.toString(),
+        data: {
+          reason: 'credit_consumption',
+          creditGrantId: creditGrant.id,
+          meterEventId: meterEvent.id,
+        },
+      });
+
+      logger.warn('Partial token transfer completed - chain balance insufficient', {
+        creditTransactionId: creditTransaction.id,
+        customerDid: customer.did,
+        currencyId: paymentCurrency.id,
+        actualBalance: chainBalanceBN.toString(),
+        expectedAmount: expectBalanceBN.toString(),
+        transferredAmount: transferAmount.toString(),
+        chainDebt: chainDebt.toString(),
+      });
+    } else {
+      logger.error('Zero chain balance - no tokens transferred', {
+        creditTransactionId: creditTransaction.id,
+        customerDid: customer.did,
+        currencyId: paymentCurrency.id,
+        expectedAmount: expectBalanceBN.toString(),
+      });
+    }
+  }
+
+  // Update transaction with result
+  await creditTransaction.update({
+    transfer_status: 'completed',
+    transfer_hash: txHash ?? undefined,
+    ...(transferResult && {
+      metadata: {
+        ...(creditTransaction.metadata || {}),
+        transfer_result: transferResult,
+      },
+    }),
+  });
+}
+
+/**
+ * Token transfer queue
+ */
+export const tokenTransferQueue = createQueue<TokenTransferJob>({
+  name: 'token-transfer',
+  onJob: handleTokenTransfer,
+  options: {
+    concurrency: 5,
+    maxRetries: 3,
+    retryDelay: 5000,
+  },
+});
+
+tokenTransferQueue.on('finished', ({ id, job }) => {
+  logger.debug('Token transfer job finished', { id, creditTransactionId: job.creditTransactionId });
+});
+
+tokenTransferQueue.on('failed', async ({ id, job, error }) => {
+  logger.error('Token transfer job failed after all retries', { id, job, error: error.message });
+
+  const creditTransaction = await CreditTransaction.findByPk(job.creditTransactionId);
+
+  if (creditTransaction && creditTransaction.transfer_status !== 'completed') {
+    await creditTransaction.update({
+      transfer_status: 'failed',
+    });
+  }
+});
+
+tokenTransferQueue.on('retry', ({ id, job }) => {
+  logger.info('Token transfer job retry scheduled', {
+    id,
+    creditTransactionId: job.creditTransactionId,
+  });
+});
+
+/**
+ * Add token transfer job to queue
+ */
+export async function addTokenTransferJob(job: TokenTransferJob): Promise<void> {
+  const jobId = `token-transfer-${job.creditTransactionId}`;
+
+  try {
+    // Check if job already exists
+    const existingJob = await tokenTransferQueue.get(jobId);
+    if (existingJob) {
+      logger.debug('Token transfer job already exists', { jobId, creditTransactionId: job.creditTransactionId });
+      return;
+    }
+
+    // Add job to queue
+    await tokenTransferQueue.push({ id: jobId, job });
+
+    logger.info('Token transfer job added to queue', {
+      jobId,
+      creditTransactionId: job.creditTransactionId,
+      customerDid: job.customerDid,
+      amount: job.amount,
+    });
+  } catch (error: any) {
+    logger.error('Failed to add token transfer job', {
+      jobId,
+      creditTransactionId: job.creditTransactionId,
+      error,
+    });
+  }
+}
+
+/**
+ * Start token transfer queue
+ */
+export async function startTokenTransferQueue(): Promise<void> {
+  try {
+    logger.info('Token transfer queue started');
+
+    // Process any pending transfers on startup
+    const pendingTransactions = await CreditTransaction.findAll({
+      where: {
+        transfer_status: 'pending',
+      },
+      limit: 100,
+      order: [['created_at', 'DESC']],
+    });
+
+    logger.info('Found pending token transfers to process', { count: pendingTransactions.length });
+
+    // Process in batches to add jobs
+    await Promise.all(
+      pendingTransactions.map(async (transaction) => {
+        try {
+          const customer = (await Customer.findByPk(transaction.customer_id))!;
+          const creditGrant = (await CreditGrant.findByPk(transaction.credit_grant_id))!;
+
+          await addTokenTransferJob({
+            creditTransactionId: transaction.id,
+            creditGrantId: transaction.credit_grant_id,
+            customerDid: customer.did,
+            amount: transaction.credit_amount,
+            paymentCurrencyId: creditGrant.currency_id,
+            meterEventId: transaction.source!,
+            subscriptionId: transaction.subscription_id || undefined,
+          });
+        } catch (error: any) {
+          logger.error('Failed to add pending transfer job', {
+            transactionId: transaction.id,
+            error: error.message,
+          });
+        }
+      })
+    );
+  } catch (error: any) {
+    logger.error('Failed to start token transfer queue', { error: error.message });
+  }
+}

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

@@ -54,6 +54,7 @@ import {
   getConnectQueryParam,
   getDataObjectFromQuery,
   getUserOrAppInfo,
+  hasObjectChanged,
   isUserInBlocklist,
 } from '../libs/util';
 import {
@@ -387,7 +388,13 @@ export async function calculateAndUpdateAmount(
 
   logger.info('Amount calculated', {
     checkoutSessionId: checkoutSession.id,
-    amount,
+    amount: {
+      subtotal: amount.subtotal,
+      total: amount.total,
+      discount: amount.discount,
+      shipping: amount.shipping,
+      tax: amount.tax,
+    },
   });
 
   if (checkoutSession.mode === 'payment' && new BN(amount.total || '0').lt(new BN('0'))) {
@@ -1190,8 +1197,11 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
           item.upsell_price_id = item.price.upsell.upsells_to_id;
         }
       });
-      await doc.update({ line_items: updatedItems });
-      await doc.update(await getCheckoutSessionAmounts(doc));
+      const amounts = await getCheckoutSessionAmounts(doc);
+      await doc.update({
+        line_items: updatedItems,
+        ...amounts,
+      });
       doc.line_items = await Price.expand(updatedItems, { upsell: true });
     }
 
@@ -1534,29 +1544,43 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         updates.invoice_prefix = Customer.getInvoicePrefix();
       }
 
-      await customer.update(updates);
-      try {
-        await blocklet.updateUserAddress(
-          {
-            did: customer.did,
-            address: Customer.formatAddressFromCustomer(customer),
-            // @ts-ignore
-            phone: customer.phone,
-          },
-          {
-            headers: {
-              cookie: req.headers.cookie || '',
-            },
-          }
-        );
-        logger.info('updateUserAddress success', {
+      if (!hasObjectChanged(updates, customer, { deepCompare: ['address'] })) {
+        logger.info('customer update skipped (no changes)', {
           did: customer.did,
         });
-      } catch (err) {
-        logger.error('updateUserAddress failed', {
-          error: err,
-          customerId: customer.id,
+      } else {
+        await customer.update(updates);
+        logger.info('customer updated', {
+          did: customer.did,
         });
+
+        try {
+          // eslint-disable-next-line no-console
+          console.time('updateUserAddress');
+          await blocklet.updateUserAddress(
+            {
+              did: customer.did,
+              address: Customer.formatAddressFromCustomer(customer),
+              // @ts-ignore
+              phone: customer.phone,
+            },
+            {
+              headers: {
+                cookie: req.headers.cookie || '',
+              },
+            }
+          );
+          // eslint-disable-next-line no-console
+          console.timeEnd('updateUserAddress');
+          logger.info('updateUserAddress success', {
+            did: customer.did,
+          });
+        } catch (err) {
+          logger.error('updateUserAddress failed', {
+            error: err,
+            customerId: customer.id,
+          });
+        }
       }
     }
 
@@ -2036,7 +2060,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
   } catch (err) {
     logger.error('Error submitting checkout session', {
       sessionId: req.params.id,
-      error: err.message,
+      error: err,
       stack: err.stack,
     });
     res.status(500).json({ code: err.code, error: err.message });
@@ -3027,10 +3051,27 @@ router.delete('/:id/remove-promotion', user, ensureCheckoutSessionOpen, async (r
   }
 });
 
+const amountSchema = Joi.object({
+  amount: Joi.string()
+    .pattern(/^\d+(\.\d+)?$/)
+    .required()
+    .messages({
+      'string.pattern.base': 'Amount must be a valid number',
+      'any.required': 'Amount is required',
+    }),
+  priceId: Joi.string().required(),
+});
 // change payment amount
 router.put('/:id/amount', ensureCheckoutSessionOpen, async (req, res) => {
   try {
-    const { amount, priceId } = req.body;
+    const { error, value } = amountSchema.validate(req.body, {
+      stripUnknown: true,
+    });
+    if (error) {
+      return res.status(400).json({ error: error.message });
+    }
+
+    const { amount, priceId } = value;
     const checkoutSession = req.doc as CheckoutSession;
     const items = await Price.expand(checkoutSession.line_items);
     const item = items.find((x) => x.price_id === priceId);
@@ -3090,7 +3131,7 @@ router.put('/:id/amount', ensureCheckoutSessionOpen, async (req, res) => {
       newItem.custom_amount = 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 });
+    logger.info('CheckoutSession updated on amount', { id: req.params.id, amount, priceId });
 
     // recalculate amount
     await checkoutSession.update(await getCheckoutSessionAmounts(checkoutSession));
@@ -3185,11 +3226,35 @@ router.get('/', auth, async (req, res) => {
       include: [],
     });
 
-    const condition = { where: { livemode: !!req.livemode } };
-    const products = (await Product.findAll(condition)).map((x) => x.toJSON());
-    const prices = (await Price.findAll(condition)).map((x) => x.toJSON());
     const docs = list.map((x) => x.toJSON());
 
+    const productIds = new Set<string>();
+    const priceIds = new Set<string>();
+    docs.forEach((x) => {
+      x.line_items?.forEach((item: any) => {
+        if (item.price_id) {
+          priceIds.add(item.price_id);
+        }
+        if (item.product_id) {
+          productIds.add(item.product_id);
+        }
+      });
+    });
+
+    const condition = { where: { livemode: !!req.livemode } };
+    const products =
+      productIds.size > 0
+        ? (await Product.findAll({ ...condition, where: { ...condition.where, id: Array.from(productIds) } })).map(
+            (x) => x.toJSON()
+          )
+        : [];
+    const prices =
+      priceIds.size > 0
+        ? (await Price.findAll({ ...condition, where: { ...condition.where, id: Array.from(priceIds) } })).map((x) =>
+            x.toJSON()
+          )
+        : [];
+
     docs.forEach((x) => {
       // @ts-ignore
       expandLineItems(x.line_items, products, prices);

package/api/src/routes/credit-grants.ts

@@ -19,6 +19,7 @@ import {
   Subscription,
 } from '../store/models';
 import { createCreditGrant } from '../libs/credit-grant';
+import { expireGrant } from '../queues/credit-grant';
 import { getMeterPriceIdsFromSubscription } from '../libs/subscription';
 import { blocklet } from '../libs/auth';
 import { formatMetadata } from '../libs/util';
@@ -354,19 +355,25 @@ router.get('/verify-availability', authMine, async (req, res) => {
 });
 
 router.get('/:id', authPortal, async (req, res) => {
-  const creditGrant = await CreditGrant.findByPk(req.params.id, {
+  const creditGrant = (await CreditGrant.findByPk(req.params.id, {
     include: [
       { model: Customer, as: 'customer' },
       { model: PaymentCurrency, as: 'paymentCurrency' },
     ],
-  });
+  })) as CreditGrant & { paymentCurrency?: PaymentCurrency };
   if (!creditGrant) {
     return res.status(404).json({ error: `Credit grant ${req.params.id} not found` });
   }
+
+  let paymentMethod = null;
+  if (creditGrant.paymentCurrency) {
+    paymentMethod = await PaymentMethod.findByPk(creditGrant.paymentCurrency.payment_method_id);
+  }
   const expandedPrices = await expandScopePrices(creditGrant);
   return res.json({
     ...creditGrant.toJSON(),
     items: expandedPrices,
+    paymentMethod,
   });
 });
 
@@ -455,8 +462,9 @@ router.post('/', auth, async (req, res) => {
   }
 });
 
-const updateMetadataSchema = Joi.object({
+const updateSchema = Joi.object({
   metadata: MetadataSchema,
+  expired: Joi.boolean().optional(),
 });
 
 router.put('/:id', auth, async (req, res) => {
@@ -464,17 +472,35 @@ router.put('/:id', auth, async (req, res) => {
   if (!creditGrant) {
     return res.status(404).json({ error: `Credit grant ${req.params.id} not found` });
   }
-  const { error } = updateMetadataSchema.validate(pick(req.body, 'metadata'));
+
+  const { error, value } = updateSchema.validate(pick(req.body, ['metadata', 'expired']), { stripUnknown: true });
   if (error) {
     return res.status(400).json({ error: `Credit grant update request invalid: ${error.message}` });
   }
-  if (req.body.metadata) {
-    const { error: metadataError } = MetadataSchema.validate(req.body.metadata);
-    if (metadataError) {
-      return res.status(400).json({ error: `metadata invalid: ${metadataError.message}` });
+
+  // Handle metadata update
+  if (value.metadata !== undefined) {
+    await creditGrant.update({ metadata: formatMetadata(value.metadata) });
+  }
+
+  // Handle expire operation first (before metadata update)
+  if (value.expired === true) {
+    // Only pending or granted grants can be expired
+    if (!['pending', 'granted'].includes(creditGrant.status)) {
+      return res.status(400).json({
+        error: `Cannot expire credit grant with status '${creditGrant.status}'. Only 'pending' or 'granted' grants can be expired.`,
+      });
     }
+
+    await expireGrant(creditGrant);
+
+    logger.info('Credit grant manually expired', {
+      creditGrantId: req.params.id,
+      previousStatus: creditGrant.status,
+      requestedBy: req.user?.did,
+    });
   }
-  await creditGrant.update({ metadata: formatMetadata(req.body.metadata) });
+
   return res.json({ success: true });
 });
 

package/api/src/routes/credit-tokens.ts

@@ -0,0 +1,38 @@
+import { Router } from 'express';
+import Joi from 'joi';
+
+import logger from '../libs/logger';
+import { authenticate } from '../libs/security';
+import { createToken } from '../integrations/arcblock/token';
+
+const router = Router();
+const auth = authenticate({ component: true, roles: ['owner', 'admin'] });
+
+const createTokenSchema = Joi.object({
+  name: Joi.string().max(64).required(),
+  symbol: Joi.string().max(16).required(),
+  decimal: Joi.number().integer().min(2).max(18).default(10),
+}).unknown(true);
+
+router.post('/', auth, async (req, res) => {
+  try {
+    const { error } = createTokenSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ error: `Token create request invalid: ${error.message}` });
+    }
+
+    const tokenFactoryState = await createToken({
+      name: req.body.name,
+      symbol: req.body.symbol,
+      decimal: req.body.decimal,
+      livemode: !!req.livemode,
+    });
+
+    return res.json(tokenFactoryState);
+  } catch (err) {
+    logger.error('create credit token failed', { error: err?.message, request: req.body });
+    return res.status(400).json({ error: err?.message });
+  }
+});
+
+export default router;

package/api/src/routes/credit-transactions.ts

@@ -14,6 +14,8 @@ import {
   MeterEvent,
   Subscription,
   PaymentCurrency,
+  PaymentMethod,
+  TCreditTransactionExpanded,
 } from '../store/models';
 
 const router = Router();
@@ -303,7 +305,7 @@ router.get('/summary', authMine, async (req, res) => {
 
 router.get('/:id', authPortal, async (req, res) => {
   try {
-    const transaction = await CreditTransaction.findByPk(req.params.id, {
+    const transaction = (await CreditTransaction.findByPk(req.params.id, {
       include: [
         {
           model: Customer,
@@ -339,14 +341,29 @@ router.get('/:id', authPortal, async (req, res) => {
           ],
           required: false,
         },
+        {
+          model: MeterEvent,
+          as: 'meterEvent',
+          attributes: ['id', 'source_data'],
+          required: false,
+        },
       ],
-    });
+    })) as CreditTransaction &
+      TCreditTransactionExpanded & { creditGrant?: CreditGrant & { paymentCurrency?: PaymentCurrency } };
 
     if (!transaction) {
       return res.status(404).json({ error: 'Credit transaction not found' });
     }
 
-    return res.json(transaction);
+    let paymentMethod = null;
+    if (transaction.creditGrant?.paymentCurrency?.payment_method_id) {
+      paymentMethod = await PaymentMethod.findByPk(transaction.creditGrant.paymentCurrency.payment_method_id);
+    }
+
+    return res.json({
+      ...transaction.toJSON(),
+      paymentMethod,
+    });
   } catch (err) {
     logger.error('get credit transaction failed', err);
     return res.status(400).json({ error: err.message });