payment-kit 1.15.21 → 1.15.23

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/invoices.ts

@@ -10,7 +10,7 @@ import { createListParamSchema, getWhereFromKvQuery, MetadataSchema } from '../l
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
 import { formatMetadata } from '../libs/util';
-import { Refund } from '../store/models';
+import { Refund, SetupIntent } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
 import { InvoiceItem } from '../store/models/invoice-item';
@@ -131,23 +131,27 @@ router.get('/', authMine, async (req, res) => {
         subscription = await Subscription.findByPk(query.subscription_id);
         if (subscription?.payment_details?.arcblock?.staking?.tx_hash) {
           const method = await PaymentMethod.findOne({ where: { type: 'arcblock', livemode: subscription.livemode } });
-          if (method) {
+          const setup = await SetupIntent.findOne({
+            where: {
+              customer_id: subscription.customer_id,
+              payment_method_id: method?.id,
+              metadata: { subscription_id: subscription.id },
+            },
+            order: [['created_at', 'ASC']],
+          });
+          const currencyId = setup?.currency_id || subscription.currency_id;
+          const currency = await PaymentCurrency.findByPk(currencyId);
+          if (method && currency) {
             const { address } = subscription.payment_details.arcblock.staking;
             const firstInvoice = await Invoice.findOne({
-              where: { subscription_id: subscription.id },
+              where: { subscription_id: subscription.id, currency_id: currencyId },
               order: [['created_at', 'ASC']],
               include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
             });
-            const last = query.o === 'asc' ? list?.[list.length - 1] : list?.[0];
-            if (subscription.payment_details.arcblock.staking.tx_hash && firstInvoice) {
+            if (firstInvoice) {
               const customer = await Customer.findByPk(firstInvoice.customer_id);
-              const currency =
-                // @ts-ignore
-                firstInvoice?.paymentCurrency ||
-                (await PaymentCurrency.findOne({
-                  where: { payment_method_id: method.id, is_base_currency: true },
-                }));
               const stakeAmountResult = await getSubscriptionStakeAmountSetup(subscription, method);
+              // @ts-ignore
               const stakeAmount = stakeAmountResult?.[currency?.contract] || '0';
 
               list.push({
@@ -187,7 +191,6 @@ router.get('/', authMine, async (req, res) => {
               const stakeRefundRecord = await Refund.findOne({
                 where: { subscription_id: subscription.id, status: 'succeeded', type: 'stake_return' },
               });
-
               if (stakeRefundRecord) {
                 list.unshift({
                   id: address as string,
@@ -198,18 +201,15 @@ router.get('/', authMine, async (req, res) => {
                   amount_due: '0',
                   amount_paid: stakeRefundRecord.amount,
                   amount_remaining: '0',
-                  ...pick(last, [
-                    'number',
-                    'paid',
-                    'auto_advance',
-                    'currency_id',
-                    'customer_id',
-                    'subscription_id',
-                    'period_start',
-                    'period_end',
-                    'created_at',
-                    'updated_at',
-                  ]),
+                  created_at: stakeRefundRecord.created_at,
+                  updated_at: stakeRefundRecord.updated_at,
+                  currency_id: stakeRefundRecord.currency_id,
+                  customer_id: stakeRefundRecord.customer_id,
+                  subscription_id: subscription.id,
+                  period_start: subscription.current_period_start,
+                  period_end: subscription.current_period_end,
+                  paid: true,
+                  ...pick(firstInvoice, ['number', 'auto_advance']),
                   // @ts-ignore
                   paymentCurrency: currency,
                   paymentMethod: method,