payment-kit 1.13.15

package/.eslintrc.js

@@ -0,0 +1,15 @@
+const { join } = require('path');
+
+module.exports = {
+  root: true,
+  extends: '@arcblock/eslint-config-ts',
+  parserOptions: {
+    project: [join(__dirname, 'tsconfig.eslint.json'), join(__dirname, 'tsconfig.json')],
+  },
+  rules: {
+    '@typescript-eslint/comma-dangle': 'off',
+    '@typescript-eslint/no-use-before-define': 'off',
+    '@typescript-eslint/lines-between-class-members': 'off',
+    'import/prefer-default-export': 'off',
+  },
+};

package/README.md

@@ -0,0 +1,3 @@
+# Payment Kit
+
+The decentralized stripe for blocklet platform.

package/api/dev.ts

@@ -0,0 +1,6 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { setupClient } from 'vite-plugin-blocklet';
+
+import { app } from './src';
+
+setupClient(app);

package/api/hooks/pre-start.js

@@ -0,0 +1,12 @@
+/* eslint-disable global-require */
+
+const isDevelopment = process.env.BLOCKLET_MODE === 'development';
+
+if (isDevelopment) {
+  // rename `require` to skip deps resolve when bundling
+  const r = require;
+  r('ts-node').register();
+  r('../src/hooks/pre-start');
+} else {
+  require('../dist/hooks/pre-start');
+}

package/api/src/hooks/pre-start.ts

@@ -0,0 +1,21 @@
+import '@blocklet/sdk/lib/error-handler';
+
+import dotenv from 'dotenv-flow';
+
+import { ensureSqliteBinaryFile } from '../libs/hooks';
+import logger from '../libs/logger';
+
+dotenv.config();
+
+const { name } = require('../../../package.json');
+
+(async () => {
+  try {
+    await ensureSqliteBinaryFile();
+    await import('../store/migrate').then((m) => m.default());
+    process.exit(0);
+  } catch (err) {
+    logger.error(`${name} pre-start error`, err.message);
+    process.exit(1);
+  }
+})();

package/api/src/index.ts

@@ -0,0 +1,92 @@
+import 'express-async-errors';
+
+import path from 'path';
+
+import fallback from '@blocklet/sdk/lib/middlewares/fallback';
+import cookieParser from 'cookie-parser';
+import cors from 'cors';
+import dotenv from 'dotenv-flow';
+import express, { ErrorRequestHandler, Request, Response } from 'express';
+import morgan from 'morgan';
+
+import { startEventQueue } from './jobs/event';
+import { startInvoiceQueue } from './jobs/invoice';
+import { startPaymentQueue } from './jobs/payment';
+import { startSubscriptionQueue } from './jobs/subscription';
+import { handlers } from './libs/auth';
+import logger, { accessLogStream } from './libs/logger';
+import { ensureI18n } from './libs/middleware';
+import routes from './routes';
+import collectHandlers from './routes/connect/collect';
+import payHandlers from './routes/connect/pay';
+import setupHandlers from './routes/connect/setup';
+import subscribeHandlers from './routes/connect/subscribe';
+import { initialize } from './store/models';
+import { sequelize } from './store/sequelize';
+
+dotenv.config();
+
+const { name, version } = require('../../package.json');
+
+initialize(sequelize);
+
+export const app = express();
+
+app.set('trust proxy', true);
+app.use(cookieParser());
+app.use(express.json({ limit: '1 mb' }));
+app.use(express.urlencoded({ extended: true, limit: '1 mb' }));
+app.use(cors());
+app.use(ensureI18n());
+
+const router = express.Router();
+handlers.attach(Object.assign({ app: router }, collectHandlers));
+handlers.attach(Object.assign({ app: router }, payHandlers));
+handlers.attach(Object.assign({ app: router }, setupHandlers));
+handlers.attach(Object.assign({ app: router }, subscribeHandlers));
+
+router.use('/api', routes);
+app.use(router);
+
+const isProduction = process.env.NODE_ENV === 'production' || process.env.ABT_NODE_SERVICE_ENV === 'production';
+
+const accessFormat =
+  isProduction
+    ? 'combined'
+    : (tokens: any, req: Request, res: Response) => [tokens.method(req, res), tokens.url(req, res), tokens.status(req, res), tokens.res(req, res, 'content-length'), '-', tokens['response-time'](req, res), 'ms'].join(' '); // prettier-ignore
+
+if (isProduction) {
+  app.use(morgan(accessFormat, { stream: accessLogStream }));
+} else {
+  app.use((req, res, next) => {
+    if (['/node_modules/.vite', '/src', '/@'].some((p) => req.originalUrl.startsWith(p))) {
+      return next();
+    }
+
+    return morgan(accessFormat, { stream: accessLogStream })(req, res, next);
+  });
+}
+
+if (isProduction) {
+  const staticDir = path.resolve(process.env.BLOCKLET_APP_DIR!, 'dist');
+  app.use(express.static(staticDir, { maxAge: '30d', index: false }));
+  app.use(fallback('index.html', { root: staticDir }));
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  app.use(<ErrorRequestHandler>((err, _req, res, _next) => {
+    logger.error(err.stack);
+    res.status(500).send('Something broke!');
+  }));
+}
+
+const port = parseInt(process.env.BLOCKLET_PORT!, 10);
+
+export const server = app.listen(port, (err?: any) => {
+  if (err) throw err;
+  logger.info(`> ${name} v${version} ready on ${port}`);
+
+  startPaymentQueue().then(() => logger.info('payment queue started'));
+  startInvoiceQueue().then(() => logger.info('invoice queue started'));
+  startSubscriptionQueue().then(() => logger.info('subscription queue started'));
+  startEventQueue().then(() => logger.info('event queue started'));
+});

package/api/src/jobs/event.ts

@@ -0,0 +1,72 @@
+import { Op } from 'sequelize';
+
+import logger from '../libs/logger';
+import createQueue from '../libs/queue';
+import { Event } from '../store/models/event';
+import { WebhookEndpoint } from '../store/models/webhook-endpoint';
+import { getJobId, webhookQueue } from './webhook';
+
+type EventJob = {
+  eventId: string;
+};
+
+export const handleEvent = async (job: EventJob) => {
+  logger.info('handleEvent', job);
+
+  const event = await Event.findByPk(job.eventId);
+  if (!event) {
+    logger.warn(`Event not found: ${job.eventId}`);
+    return;
+  }
+
+  if (!event.pending_webhooks) {
+    logger.warn(`Event already processed: ${job.eventId}`);
+    return;
+  }
+
+  const webhooks = await WebhookEndpoint.findAll({ where: { status: 'enabled', livemode: event.livemode } });
+  const eventWebhooks = webhooks.filter((webhook) => webhook.enabled_events.includes(event.type));
+  if (eventWebhooks.length === 0) {
+    logger.info(`No webhook endpoint for event: ${job.eventId}`);
+    await event.update({ pending_webhooks: 0 });
+    return;
+  }
+
+  await event.update({ pending_webhooks: eventWebhooks.length });
+  eventWebhooks.forEach((webhook) => {
+    logger.info(`Schedule webhook ${webhook.id} attempt for event: ${job.eventId}`);
+    webhookQueue.push({
+      id: getJobId(event.id, webhook.id),
+      job: { eventId: event.id, webhookId: webhook.id },
+    });
+  });
+};
+
+export const eventQueue = createQueue<EventJob>({
+  name: 'event',
+  onJob: handleEvent,
+  options: {
+    concurrency: 1,
+    maxRetries: 3,
+  },
+});
+
+export const startEventQueue = async () => {
+  const events = await Event.findAll({
+    where: {
+      pending_webhooks: { [Op.gt]: 0 },
+    },
+    attributes: ['id'],
+  });
+
+  events.forEach(async (x) => {
+    const exist = await eventQueue.get(x.id);
+    if (!exist) {
+      eventQueue.push({ id: x.id, job: { eventId: x.id } });
+    }
+  });
+};
+
+eventQueue.on('failed', ({ id, job, error }) => {
+  logger.error('Event job failed', { id, job, error });
+});

package/api/src/jobs/invoice.ts

@@ -0,0 +1,148 @@
+import { Op } from 'sequelize';
+
+import dayjs from '../libs/dayjs';
+import logger from '../libs/logger';
+import createQueue from '../libs/queue';
+import { CheckoutSession } from '../store/models/checkout-session';
+import { Invoice } from '../store/models/invoice';
+import { PaymentIntent } from '../store/models/payment-intent';
+import { Subscription } from '../store/models/subscription';
+import { paymentQueue } from './payment';
+
+type InvoiceJob = {
+  invoiceId: string;
+  retryOnError?: boolean;
+};
+
+// handle invoice payment
+// TODO: send invoice to user with email
+export const handleInvoice = async (job: InvoiceJob) => {
+  logger.info('handleInvoice', job);
+
+  const invoice = await Invoice.findByPk(job.invoiceId);
+  if (!invoice) {
+    logger.warn(`Invoice not found: ${job.invoiceId}`);
+    return;
+  }
+  if (invoice.status !== 'open') {
+    logger.warn(`Invoice not open: ${job.invoiceId}`);
+    return;
+  }
+  if (invoice.auto_advance === false) {
+    logger.warn(`Invoice not configured to auto advance: ${job.invoiceId}`);
+    return;
+  }
+
+  // no payment required
+  if (invoice.total === '0') {
+    logger.warn(`Invoice does not require payment: ${job.invoiceId}`);
+
+    await invoice.update({
+      paid: true,
+      status: 'paid',
+      amount_due: '0',
+      amount_paid: '0',
+      amount_remaining: '0',
+      attempt_count: invoice.attempt_count + 1,
+      attempted: true,
+      status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
+    });
+
+    if (invoice.subscription_id) {
+      const subscription = await Subscription.findByPk(invoice.subscription_id);
+      if (subscription && subscription.status === 'incomplete') {
+        await subscription.update({ status: subscription.trail_end ? 'trialing' : 'active' });
+        logger.info('Invoice subscription updated', subscription.id);
+      }
+    }
+
+    if (invoice.checkout_session_id) {
+      const checkoutSession = await CheckoutSession.findByPk(invoice.checkout_session_id);
+      if (checkoutSession && checkoutSession.status === 'open') {
+        await checkoutSession.update({ status: 'complete', payment_status: 'no_payment_required' });
+        logger.info('Invoice checkout session updated', checkoutSession.id);
+      }
+    }
+
+    return;
+  }
+
+  // charge automatically
+  let paymentIntent: PaymentIntent | null = null;
+  if (invoice.payment_intent_id) {
+    logger.warn(`PaymentIntent exist: ${invoice.payment_intent_id} for invoice ${job.invoiceId}`);
+    paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
+  } else {
+    const descriptionMap: any = {
+      subscription_create: 'Subscription creation',
+      subscription_cycle: 'Subscription cycle',
+    };
+    paymentIntent = await PaymentIntent.create({
+      livemode: !!invoice.livemode,
+      amount: invoice.total,
+      amount_received: '0',
+      amount_capturable: invoice.total,
+      customer_id: invoice.customer_id,
+      description: descriptionMap[invoice.billing_reason] || '',
+      currency_id: invoice.currency_id,
+      payment_method_id: invoice.default_payment_method_id,
+      invoice_id: invoice.id,
+      status: 'requires_capture',
+      capture_method: 'automatic',
+      confirmation_method: 'automatic',
+      payment_method_types: [],
+      receipt_email: invoice.customer_email,
+      statement_descriptor: invoice.statement_descriptor,
+      statement_descriptor_suffix: '',
+      setup_future_usage: 'on_session',
+      metadata: {},
+    });
+    await invoice.update({ payment_intent_id: paymentIntent.id });
+    logger.info(`PaymentIntent created: ${paymentIntent.id} for invoice ${job.invoiceId}`);
+
+    if (invoice.checkout_session_id) {
+      const checkoutSession = await CheckoutSession.findByPk(invoice.checkout_session_id);
+      if (checkoutSession && checkoutSession.status === 'open') {
+        await checkoutSession.update({ payment_intent_id: paymentIntent.id });
+        logger.info('PaymentIntent attached to invoice checkout session', checkoutSession.id);
+      }
+    }
+  }
+  if (paymentIntent) {
+    logger.info(`Payment job created: ${paymentIntent.id}`);
+    paymentQueue.push({
+      id: paymentIntent.id,
+      job: { paymentIntentId: paymentIntent.id, retryOnError: job.retryOnError },
+    });
+  }
+};
+
+export const invoiceQueue = createQueue<InvoiceJob>({
+  name: 'invoice',
+  onJob: handleInvoice,
+  options: {
+    concurrency: 1,
+    maxRetries: 3,
+  },
+});
+
+export const startInvoiceQueue = async () => {
+  const invoices = await Invoice.findAll({
+    where: {
+      status: 'open',
+      collection_method: 'charge_automatically',
+      amount_due: { [Op.gt]: '0' },
+    },
+  });
+
+  invoices.forEach(async (x) => {
+    const exist = await invoiceQueue.get(x.id);
+    if (!exist) {
+      invoiceQueue.push({ id: x.id, job: { invoiceId: x.id, retryOnError: true } });
+    }
+  });
+};
+
+invoiceQueue.on('failed', ({ id, job, error }) => {
+  logger.error('Invoice job failed', { id, job, error });
+});

package/api/src/jobs/payment.ts

@@ -0,0 +1,208 @@
+import { wallet } from '../libs/auth';
+import { getClient } from '../libs/chain/arcblock';
+import dayjs from '../libs/dayjs';
+import logger from '../libs/logger';
+import createQueue from '../libs/queue';
+import { MAX_RETRY_COUNT, getNextRetry } from '../libs/util';
+import { CheckoutSession } from '../store/models/checkout-session';
+import { Invoice } from '../store/models/invoice';
+import { PaymentCurrency } from '../store/models/payment-currency';
+import { PaymentIntent } from '../store/models/payment-intent';
+import { PaymentMethod } from '../store/models/payment-method';
+import { Subscription } from '../store/models/subscription';
+import type { PaymentError, PaymentSettings } from '../store/models/types';
+
+type PaymentJob = {
+  paymentIntentId: string;
+  paymentSettings?: PaymentSettings;
+  retryOnError?: boolean;
+};
+
+export const handlePayment = async (job: PaymentJob) => {
+  logger.info('handlePayment', job);
+
+  const paymentIntent = await PaymentIntent.findByPk(job.paymentIntentId);
+  if (!paymentIntent) {
+    logger.warn(`PaymentIntent not found: ${job.paymentIntentId}`);
+    return;
+  }
+
+  if (['requires_capture', 'processing'].includes(paymentIntent.status) === false) {
+    logger.warn(`PaymentIntent status not expected: ${paymentIntent.status}`);
+    return;
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(paymentIntent.payment_method_id);
+  if (!paymentMethod) {
+    logger.warn(`PaymentMethod not found: ${paymentIntent.payment_method_id}`);
+    return;
+  }
+
+  // FIXME: more methods supported here
+  if (paymentMethod.type !== 'arcblock') {
+    logger.warn(`Unexpected payment method type: ${paymentMethod.type}`);
+    return;
+  }
+
+  const paymentCurrency = await PaymentCurrency.findByPk(paymentIntent.currency_id);
+  if (!paymentCurrency) {
+    logger.warn(`PaymentCurrency not found: ${paymentIntent.currency_id}`);
+    return;
+  }
+
+  const invoice = await Invoice.findByPk(paymentIntent.invoice_id);
+  const paymentSettings = invoice?.payment_settings || job.paymentSettings;
+  if (!paymentSettings) {
+    logger.warn('Payment settings not found:', job);
+    return;
+  }
+
+  // try payment capture and reschedule on error
+  logger.info(`PaymentIntent capture attempt: ${paymentIntent.id}`);
+  try {
+    await paymentIntent.update({ status: 'processing' });
+    const client = getClient(paymentMethod.settings.arcblock?.api_host as string);
+    const txHash = await client.sendTransferV2Tx({
+      tx: {
+        itx: {
+          to: wallet.address,
+          value: '0',
+          assets: [],
+          tokens: [{ address: paymentCurrency.contract, value: paymentIntent.amount }],
+          data: {
+            typeUrl: 'json',
+            // @ts-ignore
+            value: {
+              appId: wallet.address,
+              paymentIntentId: paymentIntent.id,
+            },
+          },
+        },
+      },
+      delegator: paymentSettings?.payment_method_options.arcblock?.payer,
+      wallet,
+    });
+    logger.info(`PaymentIntent capture done: ${paymentIntent.id} with tx ${txHash}`);
+
+    await paymentIntent.update({
+      status: 'succeeded',
+      amount_received: paymentIntent.amount,
+      payment_details: {
+        tx_hash: txHash,
+        payer: paymentSettings?.payment_method_options.arcblock?.payer,
+      },
+    });
+
+    if (invoice) {
+      await invoice.update({
+        paid: true,
+        status: 'paid',
+        amount_due: '0',
+        amount_paid: paymentIntent.amount,
+        amount_remaining: '0',
+        attempt_count: invoice.attempt_count + 1,
+        attempted: true,
+        status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
+      });
+      logger.info(`Invoice ${invoice.id} updated on payment done: ${job.paymentIntentId}`);
+
+      if (invoice.subscription_id) {
+        const subscription = await Subscription.findByPk(invoice.subscription_id);
+        if (subscription) {
+          if (subscription.status === 'incomplete') {
+            await subscription.update({ status: subscription.trail_end ? 'trialing' : 'active' });
+            logger.info(`Subscription ${subscription.id} updated on payment done ${invoice.id}`);
+          } else {
+            await subscription.update({ status: 'active' });
+            logger.info(`Subscription ${subscription.id} moved to active after payment done ${invoice.id}`);
+          }
+        }
+      }
+
+      if (invoice.checkout_session_id) {
+        const checkoutSession = await CheckoutSession.findByPk(invoice.checkout_session_id);
+        if (checkoutSession && checkoutSession.status === 'open') {
+          await checkoutSession.update({
+            status: 'complete',
+            payment_status: 'paid',
+            payment_details: {
+              tx_hash: txHash,
+              payer: paymentSettings?.payment_method_options.arcblock?.payer,
+            },
+          });
+          logger.info(`CheckoutSession ${checkoutSession.id} updated on payment done ${invoice.id}`);
+        }
+      }
+    }
+  } catch (err) {
+    logger.error('PaymentIntent capture failed', { error: err, id: paymentIntent.id });
+
+    const error: PaymentError = {
+      type: 'card_error',
+      code: err.code,
+      message: err.message,
+      payment_settings: paymentSettings,
+      payment_method_id: paymentMethod.id,
+      payment_method_type: paymentMethod.type,
+    };
+
+    if (invoice && job.retryOnError) {
+      if (invoice.attempt_count > MAX_RETRY_COUNT) {
+        await paymentIntent.update({ status: 'requires_action', last_payment_error: error });
+        await invoice.update({ status: 'uncollectible' });
+        // FIXME: send email to customer, pause subscription
+        logger.error('PaymentIntent capture failed after max retry', { id: paymentIntent.id });
+      } else {
+        const retryAt = getNextRetry(invoice.attempt_count + 1);
+
+        await paymentIntent.update({ status: 'requires_capture', last_payment_error: error });
+        await invoice.update({
+          attempt_count: invoice.attempt_count + 1,
+          attempted: true,
+          next_payment_attempt: retryAt,
+        });
+        logger.error('PaymentIntent capture retry scheduled', { id: paymentIntent.id, retryAt });
+
+        // reschedule next attempt
+        paymentQueue.push({
+          id: paymentIntent.id,
+          job: { paymentIntentId: paymentIntent.id, retryOnError: job.retryOnError },
+          runAt: retryAt,
+        });
+      }
+    } else {
+      logger.error('PaymentIntent status reverted on capture error', { id: paymentIntent.id });
+      await paymentIntent.update({ status: 'requires_capture' });
+    }
+  }
+};
+
+export const paymentQueue = createQueue<PaymentJob>({
+  name: 'payment',
+  onJob: handlePayment,
+  options: {
+    concurrency: 1,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});
+
+export const startPaymentQueue = async () => {
+  const payments = await PaymentIntent.findAll({
+    where: {
+      status: ['requires_capture', 'processing'],
+      capture_method: 'automatic',
+    },
+  });
+
+  payments.forEach(async (x) => {
+    const exist = await paymentQueue.get(x.id);
+    if (!exist) {
+      paymentQueue.push({ id: x.id, job: { paymentIntentId: x.id } });
+    }
+  });
+};
+
+paymentQueue.on('failed', ({ id, job, error }) => {
+  logger.error('Payment job failed', { id, job, error });
+});