payment-kit 1.15.20 → 1.15.22

package/api/src/queues/subscription.ts

@@ -16,6 +16,7 @@ import {
   checkUsageReportEmpty,
   getSubscriptionCycleAmount,
   getSubscriptionCycleSetup,
+  getSubscriptionRefundSetup,
   getSubscriptionStakeAddress,
   getSubscriptionStakeReturnSetup,
   getSubscriptionStakeSlashSetup,
@@ -29,6 +30,7 @@ import { Price } from '../store/models/price';
 import { Subscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
 import { invoiceQueue } from './invoice';
+import { SubscriptionWillCanceledSchedule } from '../crons/subscription-will-canceled';
 
 type SubscriptionJob = {
   subscriptionId: string;
@@ -227,7 +229,10 @@ const handleSubscriptionBeforeCancel = async (subscription: Subscription) => {
 
     // persist invoice id
     await subscription.update({ latest_invoice_id: invoice.id });
-    logger.info('Subscription updated before cancel', { invoice: invoice.id, subscription: subscription.id });
+    logger.info('Subscription updated before cancel', {
+      subscription: subscription.id,
+      latestInvoiceId: invoice.id,
+    });
   }
 };
 
@@ -256,6 +261,9 @@ const handleSubscriptionWhenActive = async (subscription: Subscription) => {
     const now = dayjs().unix();
     if (subscription.trial_end && subscription.trial_end <= now) {
       await subscription.update({ status: 'active' });
+      logger.info('Subscription status updated from trialing to active', {
+        subscription: subscription.id,
+      });
     }
   }
 
@@ -438,6 +446,11 @@ const handleStakeSlashAfterCancel = async (subscription: Subscription) => {
       },
     },
   });
+  logger.info('PaymentIntent updated after stake slash', {
+    subscription: subscription.id,
+    paymentIntent: paymentIntent.id,
+    status: 'succeeded',
+  });
   await invoice.update({
     paid: true,
     status: 'paid',
@@ -447,6 +460,12 @@ const handleStakeSlashAfterCancel = async (subscription: Subscription) => {
     attempted: true,
     status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
   });
+
+  logger.info('Invoice updated after stake slash', {
+    subscription: subscription.id,
+    invoice: invoice.id,
+    status: 'paid',
+  });
 };
 
 const ensureReturnStake = async (subscription: Subscription) => {
@@ -626,7 +645,11 @@ const slashStakeOnCancel = async (subscription: Subscription) => {
         subscription_id: subscription.id,
       } as unknown as Invoice,
     });
-    logger.info('Invoice created for stake slash', { invoice: newInvoice.id, subscription: subscription.id });
+    logger.info('New invoice created for stake slash', {
+      subscription: subscription.id,
+      invoice: newInvoice.id,
+      amount: result.return_amount,
+    });
     invoiceQueue.push({
       id: newInvoice.id,
       job: { invoiceId: newInvoice.id, retryOnError: true },
@@ -635,6 +658,58 @@ const slashStakeOnCancel = async (subscription: Subscription) => {
   }
 };
 
+const ensureRefundOnCancel = async (subscription: Subscription) => {
+  // @ts-ignore
+  const { refund } = subscription.cancelation_details;
+  if (!['last', 'proration'].includes(refund)) {
+    logger.warn('Refund skipped because refund type is not last or proration', {
+      subscription: subscription.id,
+      refund,
+    });
+    return;
+  }
+  const result = await getSubscriptionRefundSetup(subscription, subscription.cancel_at);
+  if (result.unused === '0') {
+    logger.warn('Refund skipped because unused amount is 0', {
+      subscription: subscription.id,
+      unused: result.unused,
+    });
+    return;
+  }
+  const item = await Refund.create({
+    type: 'refund',
+    livemode: subscription.livemode,
+    amount: refund === 'last' ? result.total : result.unused,
+    description: 'refund_transfer_on_subscription_cancel',
+    status: 'pending',
+    reason: 'requested_by_admin',
+    currency_id: subscription.currency_id,
+    customer_id: subscription.customer_id,
+    payment_method_id: subscription.default_payment_method_id,
+    payment_intent_id: result.lastInvoice.payment_intent_id as string,
+    invoice_id: result.lastInvoice.id,
+    subscription_id: subscription.id,
+    attempt_count: 0,
+    attempted: false,
+    next_attempt: 0,
+    last_attempt_error: null,
+    starting_balance: '0',
+    ending_balance: '0',
+    starting_token_balance: {},
+    ending_token_balance: {},
+    metadata: {
+      requested_by: subscription.cancelation_details?.requested_by,
+      unused_period_start: refund === 'last' ? subscription.current_period_start : subscription.cancel_at,
+      unused_period_end: subscription.current_period_end,
+    },
+  });
+  logger.info('Created refund for canceled subscription', {
+    subscription: subscription.id,
+    refund: item.toJSON(),
+    refundType: refund,
+  });
+};
+
 // generate invoice for subscription periodically
 export const handleSubscription = async (job: SubscriptionJob) => {
   logger.info('handle subscription', job);
@@ -793,6 +868,25 @@ export const returnStakeQueue = createQueue({
   },
 });
 
+export const subscriptionCancelRefund = createQueue({
+  name: 'subscription-cancel-refund',
+  onJob: async (job) => {
+    const { subscriptionId } = job;
+    const subscription = await Subscription.findByPk(subscriptionId);
+    if (!subscription) {
+      return;
+    }
+    await ensureRefundOnCancel(subscription);
+  },
+  options: {
+    concurrency: 1,
+    maxRetries: 5,
+    retryDelay: 1000,
+    maxTimeout: 60000,
+    enableScheduledJob: true,
+  },
+});
+
 export async function addSubscriptionJob(
   subscription: Subscription,
   action: 'cycle' | 'cancel' | 'resume',
@@ -831,6 +925,7 @@ subscriptionQueue.on('failed', ({ id, job, error }) => {
 
 events.on('customer.subscription.past_due', async (subscription: Subscription) => {
   await subscriptionQueue.delete(subscription.id);
+  await new SubscriptionWillCanceledSchedule().reScheduleSubscriptionTasks([subscription]);
   await addSubscriptionJob(subscription, 'cancel', true, subscription.cancel_at || subscription.current_period_end);
   logger.info('subscription cancel job scheduled after past_due', {
     subscription: subscription.id,
@@ -852,6 +947,15 @@ events.on('customer.subscription.deleted', (subscription: Subscription) => {
   });
   // FIXME: ensure invoices that are open or uncollectible are voided
 
+  if (
+    subscription.cancelation_details?.refund &&
+    ['last', 'proration'].includes(subscription.cancelation_details.refund)
+  ) {
+    subscriptionCancelRefund.push({
+      id: `subscription-cancel-refund-${subscription.id}`,
+      job: { subscriptionId: subscription.id },
+    });
+  }
   if (subscription.cancelation_details?.slash_stake) {
     slashStakeQueue.push({
       id: `slash-stake-${subscription.id}`,
@@ -890,5 +994,6 @@ events.on('customer.stake.revoked', async ({ subscriptionId, tx }: { subscriptio
       comment: `Revoked by ${tx.tx.from} with tx ${tx.hash}`,
     },
   });
+  await new SubscriptionWillCanceledSchedule().reScheduleSubscriptionTasks([subscription]);
   await addSubscriptionJob(subscription, 'cancel', true, subscription.current_period_end);
 });

package/api/src/queues/usage-record.ts

@@ -27,8 +27,10 @@ type UsageRecordJob = {
 export async function handleUsageRecord(job: UsageRecordJob) {
   const lock = getLock(`${job.subscriptionId}-threshold`);
   await lock.acquire();
+  logger.info(`Lock acquired for subscription ${job.subscriptionId}`);
   const result = await doHandleUsageRecord(job);
   lock.release();
+  logger.info(`Lock released for subscription ${job.subscriptionId}`);
   return result;
 }
 
@@ -148,6 +150,8 @@ export const doHandleUsageRecord = async (job: UsageRecordJob) => {
     await subscription.update({ latest_invoice_id: invoice.id });
     logger.info(`Subscription updated on threshold: ${subscription.id}`);
   }
+
+  logger.info(`Usage record handling completed for subscription ${subscription.id}`);
 };
 
 export const usageRecordQueue = createQueue<UsageRecordJob>({

package/api/src/queues/webhook.ts

@@ -77,8 +77,11 @@ export const handleWebhook = async (job: WebhookJob) => {
       response_body: result.data || {},
       retry_count: retryCount,
     });
+    logger.info('WebhookAttempt created successfully', { eventId: event.id, webhookId: webhook.id });
 
     await event.decrement('pending_webhooks');
+    logger.info('pending_webhooks decremented', { eventId: event.id, newCount: event.pending_webhooks });
+
     logger.info('webhook attempt success', { ...job, retryCount });
   } catch (err: any) {
     logger.warn('webhook attempt error', { ...job, retryCount, message: err.message });
@@ -91,6 +94,7 @@ export const handleWebhook = async (job: WebhookJob) => {
       response_body: (err as AxiosError).response?.data || {},
       retry_count: retryCount,
     });
+    logger.info('Failed WebhookAttempt created', { eventId: event.id, webhookId: webhook.id });
 
     // reschedule next attempt
     if (retryCount < MAX_RETRY_COUNT) {
@@ -100,9 +104,14 @@ export const handleWebhook = async (job: WebhookJob) => {
           job: { eventId: event.id, webhookId: webhook.id },
           runAt: getNextRetry(retryCount),
         });
+        logger.info('scheduled webhook job', { ...job, retryCount });
       });
     } else {
       await event.decrement('pending_webhooks');
+      logger.info('Max retries reached, pending_webhooks decremented', {
+        eventId: event.id,
+        newCount: event.pending_webhooks,
+      });
     }
   }
 };

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

@@ -512,6 +512,10 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
 
 // start checkout session from payment link
 router.post('/start/:id', user, async (req, res) => {
+  logger.info('Starting checkout session from payment link', {
+    paymentLinkId: req.params.id,
+    userId: req.user?.did,
+  });
   await startCheckoutSessionFromPaymentLink(req.params.id as string, req, res);
 });
 
@@ -1010,6 +1014,10 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
           trialInDays,
           trialEnd
         );
+        logger.info('ensureStripeSubscription', {
+          subscriptionId: subscription.id,
+          stripeSubscriptionId: stripeSubscription?.id,
+        });
         if (stripeSubscription && subscription?.payment_details?.stripe?.subscription_id === stripeSubscription.id) {
           if (['active', 'trialing'].includes(stripeSubscription.status) && subscription.status === 'incomplete') {
             await handleStripeSubscriptionSucceed(subscription, stripeSubscription.status);
@@ -1028,6 +1036,14 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       }
     }
 
+    logger.info('Checkout session submitted successfully', {
+      sessionId: req.params.id,
+      paymentIntentId: paymentIntent?.id,
+      setupIntentId: setupIntent?.id,
+      subscriptionId: subscription?.id,
+      customerId: customer?.id,
+    });
+
     return res.json({
       paymentIntent,
       setupIntent,
@@ -1039,7 +1055,11 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       balance: checkoutSession.mode === 'payment' && canFastPay ? balance : null,
     });
   } catch (err) {
-    console.error(err);
+    logger.error('Error submitting checkout session', {
+      sessionId: req.params.id,
+      error: err.message,
+      stack: err.stack,
+    });
     res.status(500).json({ code: err.code, error: err.message });
   }
 });
@@ -1118,9 +1138,18 @@ router.put('/:id/downsell', user, ensureCheckoutSessionOpen, async (req, res) =>
     }
 
     const items = await Price.expand(checkoutSession.line_items, { upsell: true });
+    logger.info('Checkout session updated after downsell', {
+      sessionId: req.params.id,
+      fromPriceId: from.id,
+      newAmount: checkoutSession.amount_total,
+    });
     res.json({ ...checkoutSession.toJSON(), line_items: items });
   } catch (err) {
-    console.error(err);
+    logger.error('Error processing downsell', {
+      sessionId: req.params.id,
+      error: err.message,
+      stack: err.stack,
+    });
     res.status(500).json({ error: err.message });
   }
 });
@@ -1140,6 +1169,11 @@ router.put('/:id/expire', auth, ensureCheckoutSessionOpen, async (req, res) => {
   }
 
   await doc.update({ status: 'expired', expires_at: dayjs().unix() });
+  logger.info('Checkout session expired', {
+    sessionId: req.params.id,
+    userId: req.user?.did,
+    expiresAt: doc.expires_at,
+  });
 
   res.json(doc);
 });
@@ -1413,6 +1447,10 @@ router.put('/:id', auth, async (req, res) => {
   }
 
   await doc.update(raw);
+  logger.info('Checkout session updated', {
+    sessionId: doc.id,
+    updatedFields: Object.keys(raw),
+  });
   res.json(doc);
 });
 

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

@@ -0,0 +1,143 @@
+import type { Transaction } from '@ocap/client';
+import { fromAddress } from '@ocap/wallet';
+import { fromTokenToUnit, toBase58 } from '@ocap/util';
+import { encodeTransferItx } from 'api/src/integrations/ethereum/token';
+import { executeEvmTransaction, waitForEvmTxConfirm } from 'api/src/integrations/ethereum/tx';
+import type { CallbackArgs } from '../../libs/auth';
+import { getGasPayerExtra } from '../../libs/payment';
+import { getTxMetadata } from '../../libs/util';
+import { ensureSubscriptionRecharge, getAuthPrincipalClaim } from './shared';
+import logger from '../../libs/logger';
+
+export default {
+  action: 'recharge',
+  authPrincipal: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureSubscriptionRecharge(extraParams.subscriptionId);
+      return getAuthPrincipalClaim(paymentMethod, 'recharge');
+    },
+  },
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    let { amount } = extraParams;
+    const { paymentMethod, paymentCurrency, receiverAddress } = await ensureSubscriptionRecharge(subscriptionId);
+    amount = fromTokenToUnit(amount, paymentCurrency.decimal).toString();
+    if (paymentMethod.type === 'arcblock') {
+      const tokens = [{ address: paymentCurrency.contract as string, value: amount }];
+      // @ts-ignore
+      const itx: TransferV3Tx = {
+        outputs: [{ owner: receiverAddress, tokens, assets: [] }],
+        data: getTxMetadata({
+          rechargeCustomerId: receiverAddress,
+          subscriptionId,
+          currencyId: paymentCurrency.id,
+          amount,
+          action: 'recharge',
+        }),
+      };
+
+      const claims: { [key: string]: object } = {
+        prepareTx: {
+          type: 'TransferV3Tx',
+          description: `Recharge account for ${receiverAddress}`,
+          partialTx: { from: userDid, pk: userPk, itx },
+          requirement: { tokens },
+          chainInfo: {
+            host: paymentMethod.settings?.arcblock?.api_host as string,
+            id: paymentMethod.settings?.arcblock?.chain_id as string,
+          },
+        },
+      };
+
+      return claims;
+    }
+
+    if (paymentMethod.type === 'ethereum') {
+      return {
+        signature: {
+          type: 'eth:transaction',
+          data: toBase58(
+            Buffer.from(
+              JSON.stringify({
+                network: paymentMethod.settings?.ethereum?.chain_id,
+                tx: encodeTransferItx(receiverAddress, amount, paymentCurrency.contract as string),
+              }),
+              'utf-8'
+            )
+          ),
+        },
+      };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+  onAuth: async ({ request, userDid, claims, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { paymentMethod, paymentCurrency, receiverAddress } = await ensureSubscriptionRecharge(subscriptionId);
+    let { amount } = extraParams;
+    amount = fromTokenToUnit(amount, paymentCurrency.decimal).toString();
+
+    if (paymentMethod.type === 'arcblock') {
+      try {
+        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;
+        }
+
+        // @ts-ignore
+        const { buffer } = await client.encodeTransferV3Tx({ tx });
+        const txHash = await client.sendTransferV3Tx(
+          // @ts-ignore
+          { tx, wallet: fromAddress(userDid) },
+          getGasPayerExtra(buffer, client.pickGasPayerHeaders(request))
+        );
+
+        logger.info('Recharge successful', {
+          receiverAddress,
+          amount,
+          subscriptionId,
+          paymentMethod: paymentMethod.type,
+        });
+
+        return { hash: txHash };
+      } catch (err) {
+        console.error(err);
+        logger.error('Failed to finalize recharge on arcblock', { receiverAddress, error: err });
+        throw err;
+      }
+    }
+
+    if (paymentMethod.type === 'ethereum') {
+      try {
+        const paymentDetails = await executeEvmTransaction('transfer', userDid, claims, paymentMethod);
+        waitForEvmTxConfirm(
+          paymentMethod.getEvmClient(),
+          Number(paymentDetails.block_height),
+          paymentMethod.confirmation.block
+        )
+          .then(() => {
+            logger.info('Recharge successful', {
+              receiverAddress,
+              amount,
+              subscriptionId,
+              paymentMethod: paymentMethod.type,
+            });
+          })
+          .catch(console.error);
+
+        return { hash: paymentDetails.tx_hash };
+      } catch (err) {
+        console.error(err);
+        logger.error('Failed to finalize recharge on ethereum', { receiverAddress, error: err });
+        throw err;
+      }
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};

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

@@ -606,6 +606,31 @@ export async function ensureInvoiceForCollect(invoiceId: string) {
   };
 }
 
+export async function ensureSubscriptionRecharge(subscriptionId: string) {
+  const subscription = await Subscription.findByPk(subscriptionId);
+  if (!subscription) {
+    throw new Error(`Subscription ${subscriptionId} not found`);
+  }
+  const paymentCurrency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!paymentCurrency) {
+    throw new Error(`Currency ${subscription.currency_id} not found`);
+  }
+  const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+  if (!paymentMethod) {
+    throw new Error(`Payment method ${paymentCurrency.payment_method_id} not found`);
+  }
+  // @ts-ignore
+  const receiverAddress = subscription?.payment_details?.[paymentMethod.type]?.payer;
+  if (!receiverAddress) {
+    throw new Error(`Receiver address not found for subscription ${subscriptionId}`);
+  }
+  return {
+    paymentCurrency: paymentCurrency as PaymentCurrency,
+    paymentMethod: paymentMethod as PaymentMethod,
+    receiverAddress,
+  };
+}
+
 export function getAuthPrincipalClaim(method: PaymentMethod, action: string) {
   let chainInfo = { type: 'none', id: 'none', host: 'none' };
   if (method.type === 'arcblock') {

package/api/src/routes/customers.ts

@@ -96,8 +96,8 @@ router.get('/me', user(), async (req, res) => {
     } else {
       const [summary, stake, token] = await Promise.all([
         doc.getSummary(),
-        getStakeSummaryByDid(doc.did, doc.livemode),
-        getTokenSummaryByDid(doc.did, doc.livemode),
+        getStakeSummaryByDid(doc.did, req?.livemode || doc.livemode),
+        getTokenSummaryByDid(doc.did, req?.livemode || doc.livemode),
       ]);
       res.json({ ...doc.toJSON(), summary: { ...summary, stake, token } });
     }

package/api/src/routes/donations.ts

@@ -61,12 +61,15 @@ router.post('/', async (req, res) => {
           },
         },
       });
+      logger.info('Payment link updated successfully', { linkId: link.id });
       res.json(link.toJSON());
       return;
     }
 
+    logger.info('No existing payment link found, creating new one');
     let price = await Price.findByPkOrLookupKey(payload.target);
     if (!price) {
+      logger.info('No existing price found, creating new product and price');
       const result = await createProductAndPrices({
         type: 'service',
         livemode: req.livemode,
@@ -109,9 +112,10 @@ router.post('/', async (req, res) => {
         },
       },
     });
+    logger.info('New payment link created', { linkId: result.id });
     res.json(result);
   } catch (err) {
-    logger.error('prepare payment link for donation', err);
+    logger.error('Failed to prepare payment link for donation', err);
     res.status(400).json({ error: err.message });
   }
 });

package/api/src/routes/events.ts

@@ -5,6 +5,7 @@ import type { WhereOptions } from 'sequelize';
 import { createListParamSchema } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { Event } from '../store/models/event';
+import { blocklet } from '../libs/auth';
 
 const router = Router();
 const auth = authenticate<Event>({ component: true, roles: ['owner', 'admin'] });
@@ -61,13 +62,17 @@ router.get('/:id', auth, async (req, res) => {
     });
 
     if (doc) {
-      res.json(doc);
-    } else {
-      res.status(404).json(null);
+      const requestedBy = doc.request?.requested_by || 'system';
+      const { user } = await blocklet.getUser(requestedBy as string);
+      if (user) {
+        return res.json({ ...doc.toJSON(), requestInfo: user });
+      }
+      return res.json(doc);
     }
+    return res.status(404).json(null);
   } catch (err) {
     console.error(err);
-    res.status(500).json({ error: `Failed to get event: ${err.message}` });
+    return res.status(400).json({ error: `Failed to get event: ${err.message}` });
   }
 });