payment-kit 1.15.21 → 1.15.22

package/api/src/index.ts

@@ -19,7 +19,7 @@ import { initResourceHandler } from './integrations/blocklet/resource';
 import { ensureWebhookRegistered } from './integrations/stripe/setup';
 import { handlers } from './libs/auth';
 import logger, { accessLogStream } from './libs/logger';
-import { ensureI18n } from './libs/middleware';
+import { contextMiddleware, ensureI18n } from './libs/middleware';
 import { initEventBroadcast } from './libs/ws';
 import { startCheckoutSessionQueue } from './queues/checkout-session';
 import { startEventQueue } from './queues/event';
@@ -93,6 +93,7 @@ if (isProduction) {
   });
 }
 
+app.use(contextMiddleware);
 app.use(router);
 
 if (isProduction) {

package/api/src/libs/audit.ts

@@ -4,6 +4,7 @@ import type { LiteralUnion } from 'type-fest';
 import type { EventType } from '../store/models';
 import { Event } from '../store/models/event';
 import { events } from './event';
+import { context } from './context';
 
 const API_VERSION = '2023-09-05';
 
@@ -15,7 +16,6 @@ export async function createEvent(scope: string, type: LiteralUnion<EventType, s
     data.previous_attributes = pick(model._previousDataValues, options.fields);
   }
   // console.log('createEvent', scope, type, data, options);
-
   const event = await Event.create({
     type,
     api_version: API_VERSION,
@@ -27,6 +27,7 @@ export async function createEvent(scope: string, type: LiteralUnion<EventType, s
       // FIXME:
       id: '',
       idempotency_key: '',
+      requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
     pending_webhooks: 99, // force all events goto the event queue
@@ -69,6 +70,7 @@ export async function createStatusEvent(
       // FIXME:
       id: '',
       idempotency_key: '',
+      requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
     pending_webhooks: 99, // force all events goto the event queue
@@ -107,6 +109,7 @@ export async function createCustomEvent(
       // FIXME:
       id: '',
       idempotency_key: '',
+      requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
     pending_webhooks: 99, // force all events goto the event queue

package/api/src/libs/context.ts

@@ -0,0 +1,48 @@
+import { AsyncLocalStorage, AsyncResource } from 'async_hooks';
+
+interface RequestContext {
+  requestedBy?: string;
+  requestId?: string;
+}
+
+class RequestContextManager {
+  private storage = new AsyncLocalStorage<RequestContext>();
+  private contexts = new Map<string, RequestContext>();
+
+  getContext(requestId?: string): RequestContext {
+    if (requestId && this.contexts.has(requestId)) {
+      return this.contexts.get(requestId)!;
+    }
+    return this.storage.getStore() || {};
+  }
+
+  getRequestedBy(requestId?: string): string | undefined {
+    return this.getContext(requestId).requestedBy;
+  }
+
+  run<T>(context: RequestContext, fn: () => Promise<T> | T): Promise<T> {
+    const requestId = context.requestId || `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    this.contexts.set(requestId, {
+      ...context,
+      requestId,
+    });
+
+    return new Promise((resolve, reject) => {
+      this.storage.run({ ...context, requestId }, async () => {
+        const resource = new AsyncResource('RequestContext');
+        try {
+          const result = await resource.runInAsyncScope(fn);
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        } finally {
+          // 清理上下文
+          this.contexts.delete(requestId);
+        }
+      });
+    });
+  }
+}
+
+export const context = new RequestContextManager();

package/api/src/libs/invoice.ts

@@ -71,7 +71,7 @@ export async function getOneTimeProductInfo(invoiceId: string, paymentCurrency:
     });
     return oneTimePaymentInfo;
   } catch (err) {
-    console.error(err);
+    console.error(`Error in getOneTimeProductInfo for invoice ${invoiceId}:`, err);
     return [];
   }
 }
@@ -140,7 +140,7 @@ export async function getInvoiceShouldPayTotal(invoice: Invoice) {
     const amount = getSubscriptionCycleAmount(expandedItems, subscription.currency_id);
     return amount?.total || invoice.total;
   } catch (err) {
-    console.error(err);
+    console.error(`Error in getInvoiceShouldPayTotal for invoice ${invoice.id}:`, err);
     return invoice.total;
   }
 }

package/api/src/libs/middleware.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/prefer-default-export */
 import type { NextFunction, Request, Response } from 'express';
-
+import { verify } from '@blocklet/sdk/lib/util/verify-sign';
 import { translate } from '../locales';
+import { context } from './context';
 
 export function ensureI18n() {
   return (req: Request, _: Response, next: NextFunction) => {
@@ -10,3 +11,40 @@ export function ensureI18n() {
     next();
   };
 }
+
+export function contextMiddleware(req: Request, _res: Response, next: NextFunction) {
+  const requestId =
+    (req.headers['x-request-id'] as string) || `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  let requestedBy = 'system';
+
+  // Check component signature
+  const sig = req.get('x-component-sig');
+  const componentDid = req.get('x-component-did');
+  if (sig && componentDid) {
+    const data = typeof req.body === 'undefined' ? {} : req.body;
+    const verified = verify(data, sig);
+    if (verified) {
+      requestedBy = componentDid;
+    }
+  }
+
+  // Check user DID from headers
+  if (req.headers['x-user-did']) {
+    requestedBy = req.headers['x-user-did'] as string;
+  }
+
+  // Check authenticated user
+  if (req.user?.did) {
+    requestedBy = req.user.did;
+  }
+
+  return context.run(
+    {
+      requestId,
+      requestedBy,
+    },
+    async () => {
+      await next();
+    }
+  );
+}

package/api/src/queues/checkout-session.ts

@@ -39,10 +39,15 @@ export const checkoutSessionQueue = createQueue<CheckoutSessionJob>({
 export async function handleCheckoutSessionJob(job: CheckoutSessionJob): Promise<void> {
   const checkoutSession = await CheckoutSession.findByPk(job.id);
   if (!checkoutSession) {
+    logger.warn('CheckoutSession not found', { id: job.id });
     return;
   }
   if (job.action === 'expire') {
     if (checkoutSession.status !== 'open') {
+      logger.info('Skip expire CheckoutSession since status is not open', {
+        checkoutSession: checkoutSession.id,
+        status: checkoutSession.status,
+      });
       return;
     }
     if (checkoutSession.payment_status === 'paid') {
@@ -257,15 +262,25 @@ events.on(
   async ({ checkoutSessionId, paymentIntentId }: { checkoutSessionId: string; paymentIntentId: string }) => {
     const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
     if (!checkoutSession) {
+      logger.warn('CheckoutSession not found for pending invoice', { checkoutSessionId });
       return;
     }
     if (checkoutSession.invoice_id) {
+      logger.info('Invoice already exists for checkout session', {
+        checkoutSessionId,
+        invoiceId: checkoutSession.invoice_id,
+      });
       return;
     }
     if (checkoutSession.mode !== 'payment') {
+      logger.info('Skipping invoice creation for non-payment mode', {
+        checkoutSessionId,
+        mode: checkoutSession.mode,
+      });
       return;
     }
     if (!checkoutSession.invoice_creation?.enabled) {
+      logger.info('Invoice creation not enabled for checkout session', { checkoutSessionId });
       return;
     }
 

package/api/src/queues/event.ts

@@ -14,16 +14,16 @@ type EventJob = {
 };
 
 export const handleEvent = async (job: EventJob) => {
-  logger.info('handle event', job);
+  logger.info('Starting to handle event', job);
 
   const event = await Event.findByPk(job.eventId);
   if (!event) {
-    logger.warn('event not found', job);
+    logger.warn('Event not found', job);
     return;
   }
 
   if (!event.pending_webhooks) {
-    logger.warn('event already processed', job);
+    logger.warn('Event already processed', job);
     return;
   }
 
@@ -36,6 +36,8 @@ export const handleEvent = async (job: EventJob) => {
   }
 
   await event.update({ pending_webhooks: eventWebhooks.length });
+  logger.info(`Updated event ${event.id} with ${eventWebhooks.length} pending webhooks`);
+
   eventWebhooks.forEach(async (webhook) => {
     const attemptCount = await WebhookAttempt.count({
       where: {
@@ -53,7 +55,7 @@ export const handleEvent = async (job: EventJob) => {
       const jobId = getWebhookJobId(event.id, webhook.id);
       const exist = await webhookQueue.get(jobId);
       if (!exist) {
-        logger.info('schedule attempt for event', job);
+        logger.info(`Scheduling attempt for event ${event.id} and webhook ${webhook.id}`, job);
         webhookQueue.push({
           id: jobId,
           job: { eventId: event.id, webhookId: webhook.id },
@@ -61,6 +63,8 @@ export const handleEvent = async (job: EventJob) => {
       }
     }
   });
+
+  logger.info(`Finished handling event ${job.eventId}`);
 };
 
 export const eventQueue = createQueue<EventJob>({
@@ -80,12 +84,17 @@ export const startEventQueue = async () => {
     attributes: ['id'],
   });
 
+  logger.info(`Found ${docs.length} events with pending webhooks`);
+
   docs.forEach(async (x) => {
     const exist = await eventQueue.get(x.id);
     if (!exist) {
+      logger.info(`Pushing event ${x.id} to queue`);
       eventQueue.push({ id: x.id, job: { eventId: x.id } });
     }
   });
+
+  logger.info('Finished starting event queue');
 };
 
 eventQueue.on('failed', ({ id, job, error }) => {

package/api/src/queues/invoice.ts

@@ -57,6 +57,7 @@ export const handleInvoice = async (job: InvoiceJob) => {
       attempted: true,
       status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
     });
+    logger.info('Invoice updated to paid status', { invoiceId: invoice.id });
 
     if (invoice.subscription_id) {
       const subscription = await Subscription.findByPk(invoice.subscription_id);
@@ -118,6 +119,11 @@ export const handleInvoice = async (job: InvoiceJob) => {
     paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
     if (paymentIntent && paymentIntent.isImmutable() === false) {
       await paymentIntent.update({ status: 'requires_capture', customer_id: invoice.customer_id });
+      logger.info('PaymentIntent updated for invoice', {
+        invoiceId: invoice.id,
+        paymentIntentId: paymentIntent.id,
+        newStatus: 'requires_capture',
+      });
     }
   } else {
     const descriptionMap: any = {
@@ -149,7 +155,11 @@ export const handleInvoice = async (job: InvoiceJob) => {
       metadata: {},
     });
     await invoice.update({ payment_intent_id: paymentIntent.id });
-    logger.info('PaymentIntent created for invoice', { invoice: invoice.id, paymentIntent: paymentIntent.id });
+    logger.info('PaymentIntent created for invoice', {
+      invoiceId: invoice.id,
+      paymentIntentId: paymentIntent.id,
+      amount: paymentIntent.amount,
+    });
 
     if (invoice.checkout_session_id) {
       const checkoutSession = await CheckoutSession.findByPk(invoice.checkout_session_id);
@@ -246,15 +256,23 @@ invoiceQueue.on('failed', ({ id, job, error }) => {
 events.on('invoice.paid', async ({ id: invoiceId }) => {
   const invoice = await Invoice.findByPk(invoiceId);
   if (!invoice) {
-    logger.error('Invoice not found', { invoiceId });
+    logger.error('Invoice not found for paid event', { invoiceId });
     return;
   }
+  logger.info('Processing paid invoice', { invoiceId, billingReason: invoice.billing_reason });
+
   const checkBillingReason = ['subscription_cycle', 'subscription_cancel'];
   if (checkBillingReason.includes(invoice.billing_reason)) {
     const shouldPayTotal = await getInvoiceShouldPayTotal(invoice);
     if (shouldPayTotal !== invoice.total) {
       createEvent('Invoice', 'billing.discrepancy', invoice);
-      logger.info('create billing discrepancy event', { invoiceId, shouldPayTotal, invoiceTotal: invoice.total });
+      logger.warn('Billing discrepancy detected', {
+        invoiceId,
+        shouldPayTotal,
+        invoiceTotal: invoice.total,
+      });
+    } else {
+      logger.info('Invoice paid successfully with correct amount', { invoiceId, total: invoice.total });
     }
   }
 });

package/api/src/queues/payment.ts

@@ -577,6 +577,9 @@ export const handlePayment = async (job: PaymentJob) => {
   let result;
   try {
     await paymentIntent.update({ status: 'processing', last_payment_error: null });
+    logger.info('PaymentIntent status updated to processing', {
+      paymentIntentId: paymentIntent.id,
+    });
     if (paymentMethod.type === 'arcblock') {
       if (invoice?.billing_reason === 'slash_stake') {
         await handleStakeSlash(invoice, paymentIntent, paymentMethod, customer, paymentCurrency);

package/api/src/queues/refund.ts

@@ -175,6 +175,7 @@ const handleRefundJob = async (
           },
         },
       });
+      logger.info('Refund status updated to succeeded', { id: refund.id, txHash });
     }
 
     if (paymentMethod.type === 'ethereum') {
@@ -376,6 +377,7 @@ const handleStakeReturnJob = async (
           },
         },
       });
+      logger.info('Stake return refund status updated to succeeded', { id: refund.id, txHash });
     }
   } catch (err: any) {
     logger.error('stake return failed', { error: err, id: refund.id });
@@ -423,6 +425,7 @@ export const startRefundQueue = async () => {
     const exist = await refundQueue.get(x.id);
     if (!exist) {
       refundQueue.push({ id: x.id, job: { refundId: x.id } });
+      logger.info('Re-queued pending refund', { id: x.id });
     }
   });
 };

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/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}` });
   }
 });
 

package/api/src/routes/payment-links.ts

@@ -194,6 +194,7 @@ router.post('/', auth, async (req, res) => {
   try {
     const { error } = PaymentLinkCreateSchema.validate(req.body);
     if (error) {
+      logger.warn('Payment link create request invalid', { error: error.message, body: req.body });
       res.status(400).json({ error: `Payment link create request invalid: ${error.message}` });
       return;
     }
@@ -204,9 +205,10 @@ router.post('/', auth, async (req, res) => {
       currency_id: req.body.currency_id || req.currency.id,
       metadata: formatMetadata(req.body.metadata),
     });
+    logger.info('Payment link created successfully', { id: result.id, user: req.user?.did });
     res.json(result);
   } catch (err) {
-    logger.error('create payment link error', err);
+    logger.error('Create payment link error', { error: err.message, stack: err.stack, body: req.body });
     res.status(400).json({ error: err.message });
   }
 });
@@ -321,23 +323,33 @@ const PaymentLinkUpdateSchema = Joi.object({
 router.put('/:id', auth, async (req, res) => {
   const { error } = PaymentLinkUpdateSchema.validate(req.body);
   if (error) {
+    logger.warn('Payment link update request invalid', { error: error.message, id: req.params.id, body: req.body });
     return res.status(400).json({ error: `Payment link update request invalid: ${error.message}` });
   }
   const doc = await PaymentLink.findByPk(req.params.id);
 
   if (!doc) {
+    logger.warn('Payment link not found for update', { id: req.params.id });
     return res.status(404).json({ error: 'payment link not found' });
   }
   if (doc.active === false) {
+    logger.warn('Attempt to update archived payment link', { id: req.params.id });
     return res.status(403).json({ error: 'payment link archived' });
   }
-  // if (doc.locked) {
-  //   return res.status(403).json({ error: 'payment link locked' });
-  // }
 
-  await doc.update(formatBeforeSave(Object.assign({}, doc.dataValues, req.body)));
-
-  res.json(doc);
+  try {
+    await doc.update(formatBeforeSave(Object.assign({}, doc.dataValues, req.body)));
+    logger.info('Payment link updated successfully', { id: req.params.id, user: req.user?.did });
+    res.json(doc);
+  } catch (err) {
+    logger.error('Update payment link error', {
+      error: err.message,
+      stack: err.stack,
+      id: req.params.id,
+      body: req.body,
+    });
+    res.status(500).json({ error: 'Failed to update payment link' });
+  }
 });
 
 // archive
@@ -345,19 +357,23 @@ router.put('/:id/archive', auth, async (req, res) => {
   const doc = await PaymentLink.findByPk(req.params.id);
 
   if (!doc) {
+    logger.warn('Payment link not found for archiving', { id: req.params.id });
     return res.status(404).json({ error: 'payment link not found' });
   }
 
   if (doc.active === false) {
+    logger.warn('Attempt to archive already archived payment link', { id: req.params.id });
     return res.status(403).json({ error: 'payment link already archived' });
   }
 
-  // if (doc.locked) {
-  //   return res.status(403).json({ error: 'payment link locked' });
-  // }
-
-  await doc.update({ active: false });
-  return res.json(doc);
+  try {
+    await doc.update({ active: false });
+    logger.info('Payment link archived successfully', { id: req.params.id, user: req.user?.did });
+    return res.json(doc);
+  } catch (err) {
+    logger.error('Archive payment link error', { error: err.message, stack: err.stack, id: req.params.id });
+    return res.status(500).json({ error: 'Failed to archive payment link' });
+  }
 });
 
 // delete
@@ -372,12 +388,14 @@ router.delete('/:id', auth, async (req, res) => {
     return res.status(403).json({ error: 'payment link archived' });
   }
 
-  // if (doc.locked) {
-  //   return res.status(403).json({ error: 'payment link locked' });
-  // }
-
-  await doc.destroy();
-  return res.json(doc);
+  try {
+    await doc.destroy();
+    logger.info('Payment link deleted successfully', { id: req.params.id, user: req.user?.did });
+    return res.json(doc);
+  } catch (err) {
+    logger.error('Delete payment link error', { error: err.message, stack: err.stack, id: req.params.id });
+    return res.status(500).json({ error: 'Failed to delete payment link' });
+  }
 });
 
 router.post('/stash', auth, async (req, res) => {
@@ -393,12 +411,14 @@ router.post('/stash', auth, async (req, res) => {
     let doc = await PaymentLink.findByPk(raw.id);
     if (doc) {
       await doc.update({ ...formatBeforeSave(req.body), livemode: raw.livemode });
+      logger.info('Stashed payment link updated', { id: raw.id, user: req.user?.did });
     } else {
       doc = await PaymentLink.create(raw as PaymentLink);
+      logger.info('New stashed payment link created', { id: raw.id, user: req.user?.did });
     }
     res.json(doc);
   } catch (err) {
-    console.error(err);
+    logger.error('Stash payment link error', { error: err.message, stack: err.stack, body: req.body });
     res.status(500).json({ error: err.message });
   }
 });

package/api/src/routes/prices.ts

@@ -217,9 +217,10 @@ router.post('/', auth, async (req, res) => {
       quantity_sold: 0,
     });
 
+    logger.info(`Price created: ${result?.id}`, { priceId: result?.id, requestedBy: req.user?.did });
     res.json(result);
   } catch (err) {
-    console.error(err);
+    logger.error('Error creating price', { error: err.message, request: req.body });
     res.status(400).json({ error: err.message });
   }
 });
@@ -346,9 +347,14 @@ router.put('/:id', auth, async (req, res) => {
     }
   }
 
-  await doc.update(Price.formatBeforeSave(updates));
-
-  return res.json(await getExpandedPrice(req.params.id as string));
+  try {
+    await doc.update(Price.formatBeforeSave(updates));
+    logger.info(`Price updated: ${req.params.id}`, { priceId: req.params.id, updates, requestedBy: req.user?.did });
+    return res.json(await getExpandedPrice(req.params.id as string));
+  } catch (err) {
+    logger.error('Error updating price', { error: err.message, request: req.body });
+    return res.status(400).json({ error: err.message });
+  }
 });
 
 // archive
@@ -369,6 +375,7 @@ router.put('/:id/archive', auth, async (req, res) => {
 
   await price.update({ active: false });
 
+  logger.info(`Price archived: ${req.params.id}`, { priceId: req.params.id, requestedBy: req.user?.did });
   return res.json(await getExpandedPrice(req.params.id as string));
 });
 
@@ -431,6 +438,12 @@ router.put('/:id/inventory', auth, async (req, res) => {
       }
       await price.increment('quantity_sold', { by: req.body.quantity });
     }
+    logger.info(`Price inventory updated: ${req.params.id}`, {
+      priceId: req.params.id,
+      action: req.body.action,
+      quantity: req.body.quantity,
+      requestedBy: req.user?.did,
+    });
     return res.json(await getExpandedPrice(req.params.id as string));
   } catch (err) {
     logger.error('update price inventory error', err);

package/api/src/routes/products.ts

@@ -161,6 +161,12 @@ router.post('/', auth, async (req, res) => {
       currency_id: req.currency.id,
       metadata: formatMetadata(req.body.metadata),
     });
+    logger.info('Product and prices created', {
+      productId: result.id,
+      name: result.name,
+      priceCount: result.prices.length,
+      requestedBy: req.user?.did,
+    });
     res.json(result);
   } catch (err) {
     logger.error('create product error', err);
@@ -300,7 +306,11 @@ router.put('/:id', auth, async (req, res) => {
     updates.metadata = formatMetadata(updates.metadata);
   }
   await product.update(updates);
-
+  logger.info('Product updated', {
+    productId: product.id,
+    updatedFields: Object.keys(updates),
+    requestedBy: req.user?.did,
+  });
   return res.json(await Product.expand(req.params.id as string));
 });
 
@@ -346,7 +356,10 @@ router.delete('/:id', auth, async (req, res) => {
 
     await product.destroy();
     await Price.destroy({ where: { product_id: product.id } });
-
+    logger.info('Product and associated prices deleted', {
+      productId: product.id,
+      requestedBy: req.user?.did,
+    });
     return res.json(product);
   } catch (err) {
     logger.error('delete product error', err);
@@ -415,6 +428,12 @@ router.post('/batch-price-update', auth, async (req, res) => {
       })
     );
 
+    logger.info('Batch price update completed', {
+      updatedCount: updated.length,
+      dryRun,
+      factor,
+      requestedBy: req.user?.did,
+    });
     return res.json(updated);
   } catch (err) {
     logger.error('batch price update error', err);

package/api/src/routes/refunds.ts

@@ -169,10 +169,16 @@ router.post('/', authAdmin, async (req, res) => {
       ...req.params,
       ...req.body,
       result: item.toJSON(),
+      requestedBy: req.user?.did,
     });
     res.json(item);
   } catch (err) {
-    logger.error('create refund error', err);
+    logger.error('Create refund failed', {
+      error: err.message,
+      stack: err.stack,
+      requestBody: req.body,
+      requestedBy: req.user?.did,
+    });
     res.status(400).json({ error: err.message });
   }
 });
@@ -241,10 +247,21 @@ router.put('/:id', authAdmin, async (req, res) => {
     }
 
     await doc.update(raw);
+    logger.info('Refund updated', {
+      refundId: doc.id,
+      updatedFields: Object.keys(raw),
+      requestedBy: req.user?.did,
+    });
     res.json(doc);
   } catch (err) {
-    console.error(err);
-    res.json(null);
+    logger.error('Update refund failed', {
+      refundId: req.params.id,
+      error: err.message,
+      stack: err.stack,
+      requestBody: req.body,
+      requestedBy: req.user?.did,
+    });
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 

package/api/src/routes/subscription-items.ts

@@ -11,6 +11,7 @@ import { formatMetadata } from '../libs/util';
 import { Price, Product, Subscription, SubscriptionItem, UsageRecord } from '../store/models';
 import { forwardUsageRecordToStripe } from '../integrations/stripe/resource';
 import { usageRecordQueue } from '../queues/usage-record';
+import logger from '../libs/logger';
 
 const router = Router();
 const auth = authenticate<SubscriptionItem>({ component: true, roles: ['owner', 'admin'] });
@@ -42,6 +43,13 @@ router.post('/', auth, async (req, res) => {
   }
 
   const doc = await SubscriptionItem.create(raw as SubscriptionItem);
+  logger.info('SubscriptionItem created', {
+    id: doc.id,
+    subscriptionId: doc.subscription_id,
+    priceId: doc.price_id,
+    quantity: doc.quantity,
+    requestedBy: req.user?.did,
+  });
   return res.json(doc);
 });
 
@@ -135,7 +143,12 @@ router.put('/:id', auth, async (req, res) => {
   }
 
   await doc.update(updates);
-
+  logger.info('SubscriptionItem updated', {
+    id: doc.id,
+    subscriptionId: doc.subscription_id,
+    updatedFields: Object.keys(updates),
+    requestedBy: req.user?.did,
+  });
   return res.json(doc);
 });
 
@@ -156,7 +169,12 @@ router.delete('/:id', auth, async (req, res) => {
   }
 
   await doc.destroy();
-
+  logger.info('SubscriptionItem deleted', {
+    id: doc.id,
+    subscriptionId: doc.subscription_id,
+    clearUsage: req.body.clear_usage,
+    requestedBy: req.user?.did,
+  });
   return res.json(doc);
 });
 
@@ -198,11 +216,23 @@ router.post('/:id/add-usage-quantity', auth, async (req, res) => {
       timestamp: now,
     } as UsageRecord);
 
+    logger.info('Usage quantity added', {
+      subscriptionItemId: subscriptionItem.id,
+      subscriptionId: subscription.id,
+      quantity,
+      timestamp: now,
+      requestedBy: req.user?.did,
+    });
+
     if (subscription.billing_thresholds?.amount_gte) {
       usageRecordQueue.push({
         id: `usage-${subscription.id}`,
         job: { subscriptionId: subscription.id, subscriptionItemId: subscriptionItem.id },
       });
+      logger.info('Usage record pushed to queue', {
+        subscriptionId: subscription.id,
+        subscriptionItemId: subscriptionItem.id,
+      });
     }
 
     await forwardUsageRecordToStripe(subscriptionItem, {
@@ -210,6 +240,13 @@ router.post('/:id/add-usage-quantity', auth, async (req, res) => {
       timestamp: now,
       action: 'increment',
     });
+    logger.info('Usage record forwarded to Stripe', {
+      subscriptionItemId: subscriptionItem.id,
+      quantity,
+      timestamp: now,
+      action: 'increment',
+    });
+
     return res.json(usageRecord);
   } catch (err) {
     console.error(err);

package/api/src/routes/subscriptions.ts

@@ -407,7 +407,14 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
   }
   await subscription.update(updates);
   await new SubscriptionWillCanceledSchedule().reScheduleSubscriptionTasks([subscription]);
-
+  logger.info('Update subscription for cancel request successful', {
+    subscriptionId: subscription.id,
+    customerId: subscription.customer_id,
+    reason: req.body.reason,
+    cancelAt: subscription.cancel_at,
+    requestedBy: req.user?.did,
+    updates,
+  });
   return res.json(subscription);
 });
 
@@ -1105,7 +1112,11 @@ router.put('/:id', authPortal, async (req, res) => {
         }
       }
     }
-
+    logger.info('Subscription updated successfully', {
+      subscriptionId: subscription.id,
+      updatedFields: Object.keys(updates),
+      newStatus: subscription.status,
+    });
     return res.json({ ...subscription.toJSON(), connectAction });
   } catch (err) {
     console.error(err);
@@ -1624,8 +1635,16 @@ router.delete('/:id', auth, async (req, res) => {
   await UsageRecord.destroy({ where: { subscription_item_id: items.map((x) => x.id) } });
   await SubscriptionItem.destroy({ where: { subscription_id: doc.id } });
   await doc.destroy();
-  logger.info('subscription deleted', { subscription: req.params.id });
-
+  logger.info('Subscription deleted successfully', {
+    subscriptionId: req.params.id,
+    deletedRelatedRecords: {
+      invoiceItems: await InvoiceItem.count({ where: { subscription_id: doc.id } }),
+      invoices: await Invoice.count({ where: { subscription_id: doc.id } }),
+      usageRecords: await UsageRecord.count({ where: { subscription_item_id: items.map((x) => x.id) } }),
+      subscriptionItems: items.length,
+    },
+    requestedBy: req.user?.did,
+  });
   return res.json(doc);
 });
 
@@ -1691,6 +1710,12 @@ router.put('/:id/slash-stake', auth, async (req, res) => {
     return res.status(400).json({ error: 'Staking not found on subscription payment detail' });
   }
   try {
+    logger.warn('Stake slash initiated', {
+      subscriptionId: subscription.id,
+      slashReason: req.body.slashReason,
+      requestedBy: req.user?.did,
+    });
+
     await subscription.update({
       // @ts-ignore
       cancelation_details: {
@@ -1703,6 +1728,13 @@ router.put('/:id/slash-stake', auth, async (req, res) => {
       id: `slash-stake-${subscription.id}`,
       job: { subscriptionId: subscription.id },
     });
+    logger.info('Stake slash scheduled successfully', {
+      subscriptionId: subscription.id,
+      result,
+      slashReason: req.body.slashReason,
+      requestedBy: req.user?.did,
+      stakingAddress: address,
+    });
     return res.json(result);
   } catch (err) {
     logger.error('subscription slash stake failed', { subscription: subscription.id, error: err });

package/api/src/routes/usage-records.ts

@@ -45,17 +45,36 @@ router.post('/', auth, async (req, res) => {
   });
   if (doc) {
     if (doc.billed) {
+      logger.info('UsageRecord updated', {
+        subscriptionItemId: raw.subscription_item_id,
+        timestamp: raw.timestamp,
+        newQuantity: raw.quantity,
+      });
       return res.status(400).json({ error: 'UsageRecord is immutable because already billed' });
     }
     if (req.body.action === 'increment') {
       await doc.increment('quantity', { by: raw.quantity });
+      logger.info('UsageRecord incremented', {
+        subscriptionItemId: raw.subscription_item_id,
+        timestamp: raw.timestamp,
+        incrementBy: raw.quantity,
+      });
     } else {
       if (subscription.billing_thresholds?.amount_gte) {
+        logger.warn('Invalid action for subscription with billing_thresholds', {
+          subscriptionId: subscription.id,
+          action: req.body.action,
+        });
         return res
           .status(400)
           .json({ error: 'UsageRecord action must be `increment` for subscriptions with billing_thresholds' });
       }
       await doc.update({ quantity: raw.quantity });
+      logger.info('UsageRecord updated', {
+        subscriptionItemId: raw.subscription_item_id,
+        timestamp: raw.timestamp,
+        newQuantity: raw.quantity,
+      });
     }
   } else {
     raw.livemode = req.livemode;
@@ -67,6 +86,10 @@ router.post('/', auth, async (req, res) => {
       id: `usage-${subscription.id}`,
       job: { subscriptionId: subscription.id, subscriptionItemId: item.id },
     });
+    logger.info('UsageRecord pushed to queue', {
+      subscriptionId: subscription.id,
+      subscriptionItemId: item.id,
+    });
   }
 
   await forwardUsageRecordToStripe(item, {
@@ -75,6 +98,12 @@ router.post('/', auth, async (req, res) => {
     action: req.body.action,
   });
 
+  logger.info('UsageRecord forwarded to Stripe', {
+    subscriptionItemId: item.id,
+    quantity: Number(raw.quantity),
+    timestamp: raw.timestamp,
+    action: req.body.action,
+  });
   return res.json(doc);
 });
 

package/api/src/store/models/event.ts

@@ -24,6 +24,7 @@ export class Event extends Model<InferAttributes<Event>, InferCreationAttributes
   declare request: {
     id: string;
     idempotency_key: string;
+    requested_by?: string;
   };
 
   // Number of webhooks that have yet to be successfully delivered

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.15.21
+version: 1.15.22
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.15.21",
+  "version": "1.15.22",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -52,7 +52,7 @@
     "@arcblock/validator": "^1.18.136",
     "@blocklet/js-sdk": "^1.16.32",
     "@blocklet/logger": "^1.16.32",
-    "@blocklet/payment-react": "1.15.21",
+    "@blocklet/payment-react": "1.15.22",
     "@blocklet/sdk": "^1.16.32",
     "@blocklet/ui-react": "^2.10.51",
     "@blocklet/uploader": "^0.1.46",
@@ -118,7 +118,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.32",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.15.21",
+    "@blocklet/payment-types": "1.15.22",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -160,5 +160,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "b27debca52a2ea7f93a2a237053b8e171f8be3a2"
+  "gitHead": "12a3cbcf04d0c8bdbbf33c04d07cecfb24bd3e9b"
 }

package/src/components/webhook/attempts.tsx

@@ -2,7 +2,7 @@
 import CodeBlock from '@arcblock/ux/lib/CodeBlock';
 import { api, formatTime } from '@blocklet/payment-react';
 import type { Paginated, TEvent, TWebhookAttemptExpanded } from '@blocklet/payment-types';
-import { CheckCircleOutlined, ErrorOutlined } from '@mui/icons-material';
+import { CheckCircleOutlined, ErrorOutlined, InfoOutlined } from '@mui/icons-material';
 import {
   Box,
   Button,
@@ -15,12 +15,15 @@ import {
   ListSubheader,
   Stack,
   Typography,
+  Popper,
+  Paper,
 } from '@mui/material';
 import { useInfiniteScroll } from 'ahooks';
 import React, { useEffect, useState } from 'react';
 
 import { isEmpty } from 'lodash';
 import { isSuccessAttempt } from '../../libs/util';
+import InfoCard from '../info-card';
 
 const fetchData = (params: Record<string, any> = {}): Promise<Paginated<TWebhookAttemptExpanded>> => {
   const search = new URLSearchParams();
@@ -45,7 +48,7 @@ const groupAttemptsByDate = (attempts: TWebhookAttemptExpanded[]) => {
 type Props = {
   event_id?: string;
   webhook_endpoint_id?: string;
-  event?: TEvent;
+  event?: TEvent & { requestInfo?: { avatar: string; email: string; did: string } };
 };
 
 WebhookAttempts.defaultProps = {
@@ -82,6 +85,35 @@ export default function WebhookAttempts({ event_id, webhook_endpoint_id, event }
     setSelected(attempt);
   };
 
+  const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null);
+
+  const handleClick = (e: React.MouseEvent<HTMLElement>) => {
+    setAnchorEl(anchorEl ? null : e.currentTarget);
+  };
+
+  useEffect(() => {
+    const handleClickOutside = (e: MouseEvent) => {
+      if (anchorEl && !anchorEl.contains(e.target as Node) && !(e.target as Element).closest('.popper-content')) {
+        setAnchorEl(null);
+      }
+    };
+
+    const handleScroll = (e: Event) => {
+      // @ts-ignore
+      if (anchorEl && !e.target?.closest('.popper-content')) {
+        setAnchorEl(null);
+      }
+    };
+
+    document.addEventListener('click', handleClickOutside);
+    window.addEventListener('scroll', handleScroll, true);
+
+    return () => {
+      document.removeEventListener('click', handleClickOutside);
+      window.removeEventListener('scroll', handleScroll, true);
+    };
+  }, [anchorEl]);
+
   if (loading) {
     return <CircularProgress />;
   }
@@ -146,7 +178,94 @@ export default function WebhookAttempts({ event_id, webhook_endpoint_id, event }
         )}
         {data?.list.length === 0 && event && (
           <Box>
-            <Typography variant="h6">Event Data</Typography>
+            <Stack direction="row" alignItems="center" spacing={1}>
+              <Typography variant="h6">Event Data</Typography>
+              <>
+                {/* @ts-ignore */}
+                <InfoOutlined
+                  fontSize="small"
+                  onClick={handleClick}
+                  sx={{
+                    color: 'text.secondary',
+                    opacity: 0.6,
+                    cursor: 'pointer',
+                  }}
+                />
+                <Popper
+                  open={Boolean(anchorEl)}
+                  anchorEl={anchorEl}
+                  placement="right"
+                  sx={{
+                    zIndex: 1000,
+                    '@media (max-width: 600px)': {
+                      '& .MuiPaper-root': {
+                        width: 'calc(100vw - 32px)',
+                        maxWidth: 'none',
+                      },
+                    },
+                  }}
+                  modifiers={[
+                    {
+                      name: 'preventOverflow',
+                      options: {
+                        boundary: window,
+                        altAxis: true,
+                        padding: 16,
+                      },
+                    },
+                    {
+                      name: 'flip',
+                      options: {
+                        fallbackPlacements: ['bottom'],
+                      },
+                    },
+                    {
+                      name: 'matchWidth',
+                      enabled: true,
+                      fn: ({ state }) => {
+                        if (window.innerWidth <= 600) {
+                          state.styles.popper = {
+                            ...state.styles.popper,
+                            width: 'calc(100vw - 32px)',
+                            maxWidth: 'none',
+                          };
+                        }
+                        return state;
+                      },
+                    },
+                  ]}>
+                  <Paper
+                    className="popper-content"
+                    elevation={3}
+                    sx={{
+                      p: 2,
+                      border: '1px solid',
+                      borderColor: 'divider',
+                      maxWidth: 300,
+                      '@media (max-width: 600px)': {
+                        maxWidth: 'none',
+                        margin: '0 auto',
+                      },
+                    }}>
+                    {event.requestInfo ? (
+                      <>
+                        <Typography variant="caption" color="text.secondary" sx={{ mb: 1, display: 'block' }}>
+                          Requested by:
+                        </Typography>
+                        <InfoCard
+                          logo={event.requestInfo.avatar}
+                          name={event.requestInfo.email}
+                          description={event.requestInfo.did || event.request.requested_by}
+                          size={40}
+                        />
+                      </>
+                    ) : (
+                      <Typography>Requested by: {event.request?.requested_by || 'system'}</Typography>
+                    )}
+                  </Paper>
+                </Popper>
+              </>
+            </Stack>
             <CodeBlock language="json">{JSON.stringify(event.data, null, 2)}</CodeBlock>
           </Box>
         )}