payment-kit 1.18.9 → 1.18.11

package/api/src/libs/util.ts

@@ -11,7 +11,7 @@ import { joinURL, withQuery, withTrailingSlash } from 'ufo';
 import axios from 'axios';
 import dayjs from './dayjs';
 import { blocklet, wallet } from './auth';
-import type { Subscription } from '../store/models';
+import type { PaymentMethod, Subscription } from '../store/models';
 import logger from './logger';
 
 export const OCAP_PAYMENT_TX_TYPE = 'fg:t:transfer_v2';
@@ -73,7 +73,7 @@ export const STRIPE_EVENTS: any[] = [
   'refund.updated',
 ];
 
-const api = axios.create({
+export const api = axios.create({
   timeout: 10 * 1000,
 });
 
@@ -458,3 +458,53 @@ export function getAdminBillingSubscriptionUrl({
 export function getCustomerIndexUrl({ locale, userDid }: { locale: string; userDid: string }) {
   return getUrl(withQuery('customer', { locale, ...getConnectQueryParam({ userDid }) }));
 }
+
+// Check if user is in blocklist
+export async function isUserInBlocklist(did: string, paymentMethod: PaymentMethod): Promise<boolean> {
+  try {
+    // Get API host from payment method settings
+    // @ts-ignore
+    const apiHost = paymentMethod?.settings?.[paymentMethod.type]?.api_host;
+    if (!apiHost) {
+      logger.warn('No API host found in payment method settings', { paymentMethodId: paymentMethod.id });
+      return false;
+    }
+
+    // Get user information
+    const { user }: { user: any } = await blocklet.getUser(did);
+    if (!user) {
+      logger.error('User not found', { did });
+      return false;
+    }
+    // Get all wallet DIDs associated with the user
+    const connectedAccounts = user.connectedAccounts || user.extraConfigs?.connectedAccounts || [];
+    const walletDids = connectedAccounts
+      .filter((account: any) => account.provider === 'wallet')
+      .map((account: any) => account.did);
+
+    if (!walletDids.length) {
+      logger.info('No wallet DIDs found for user', { did });
+      return false;
+    }
+
+    const blockedUrl = joinURL(apiHost, '/blocked');
+    const blockedResponse = await api.get(blockedUrl);
+    const blockedDids = blockedResponse.data || [];
+
+    if (!Array.isArray(blockedDids) || blockedDids.length === 0) {
+      return false;
+    }
+
+    // Check if any of the user's DIDs are in the blocklist
+    const isBlocked = walletDids.some((walletDid: string) => blockedDids.includes(walletDid));
+
+    if (isBlocked) {
+      logger.info('User is in blocklist', { did, walletDids, blockedDids });
+    }
+
+    return isBlocked;
+  } catch (error) {
+    logger.error('Error checking blocklist', { error: error.message, did });
+    return false; // Default to allowing payment on error
+  }
+}

package/api/src/libs/ws.ts

@@ -1,25 +1,91 @@
 import { sendToRelay } from '@blocklet/sdk/service/notification';
-
-import type { CheckoutSession, Invoice, PaymentIntent } from '../store/models';
+import { publish } from '@blocklet/sdk/service/eventbus';
+import type { CheckoutSession, Invoice, PaymentIntent, Subscription, Refund } from '../store/models';
 import { events } from './event';
 
-export function broadcast(eventName: string, data: any) {
+export function broadcast(eventName: string, data: any, extraParams?: Record<string, any>) {
   sendToRelay('events', eventName, data).catch((err: any) => {
-    console.error(`Failed to broadcast event: ${eventName}`, err);
+    console.error(`Failed to broadcast event via relay: ${eventName}`, err);
+  });
+
+  publish(eventName, {
+    id: data.id,
+    time: new Date().toISOString(),
+    data: {
+      object: data,
+      extraParams,
+    },
+  }).catch((err: any) => {
+    console.error(`Failed to publish event via EventBus: ${eventName}`, err);
   });
 }
 
 export function initEventBroadcast() {
-  events.on('payment_intent.succeeded', (data: PaymentIntent) => {
-    broadcast('payment_intent.succeeded', data);
+  // Checkout Events
+  events.on('checkout.session.completed', (data: CheckoutSession, extraParams?: Record<string, any>) => {
+    broadcast('checkout.session.completed', data, extraParams);
+  });
+  events.on('checkout.session.nft_minted', (data: CheckoutSession, extraParams?: Record<string, any>) => {
+    broadcast('checkout.session.nft_minted', data, extraParams);
+  });
+
+  // Payment Events
+  events.on('payment_intent.succeeded', (data: PaymentIntent, extraParams?: Record<string, any>) => {
+    broadcast('payment_intent.succeeded', data, extraParams);
+  });
+  events.on('payment_intent.payment_failed', (data: PaymentIntent, extraParams?: Record<string, any>) => {
+    broadcast('payment_intent.payment_failed', data, extraParams);
+  });
+  events.on('invoice.paid', (data: Invoice, extraParams?: Record<string, any>) => {
+    broadcast('invoice.paid', data, extraParams);
+  });
+  events.on('refund.succeeded', (data: Refund, extraParams?: Record<string, any>) => {
+    broadcast('refund.succeeded', data, extraParams);
+  });
+
+  // Subscription Events
+  events.on('customer.subscription.created', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.created', data, extraParams);
   });
-  events.on('checkout.session.completed', (data: CheckoutSession) => {
-    broadcast('checkout.session.completed', data);
+  events.on('customer.subscription.started', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.started', data, extraParams);
+  });
+  events.on('customer.subscription.renewed', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.renewed', data, extraParams);
+  });
+  events.on('customer.subscription.upgraded', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.upgraded', data, extraParams);
+  });
+  events.on('customer.subscription.updated', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.updated', data, extraParams);
+  });
+  events.on('customer.subscription.deleted', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.deleted', data, extraParams);
+  });
+  events.on('customer.subscription.paused', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.paused', data, extraParams);
+  });
+  events.on('customer.subscription.resumed', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.resumed', data, extraParams);
+  });
+  events.on('customer.subscription.past_due', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.past_due', data, extraParams);
+  });
+  events.on('customer.subscription.recovered', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.recovered', data, extraParams);
+  });
+  events.on('customer.subscription.renew_failed', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.renew_failed', data, extraParams);
+  });
+
+  // Trial Events
+  events.on('customer.subscription.trial_start', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.trial_start', data, extraParams);
   });
-  events.on('checkout.session.nft_minted', (data: CheckoutSession) => {
-    broadcast('checkout.session.nft_minted', data);
+  events.on('customer.subscription.trial_will_end', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.trial_will_end', data, extraParams);
   });
-  events.on('invoice.paid', (data: Invoice) => {
-    broadcast('invoice.paid', data);
+  events.on('customer.subscription.trial_end', (data: Subscription, extraParams?: Record<string, any>) => {
+    broadcast('customer.subscription.trial_end', data, extraParams);
   });
 }

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

@@ -48,7 +48,13 @@ import {
   getSubscriptionCreateSetup,
   getSubscriptionTrialSetup,
 } from '../libs/subscription';
-import { CHECKOUT_SESSION_TTL, formatAmountPrecisionLimit, formatMetadata, getDataObjectFromQuery } from '../libs/util';
+import {
+  CHECKOUT_SESSION_TTL,
+  formatAmountPrecisionLimit,
+  formatMetadata,
+  getDataObjectFromQuery,
+  isUserInBlocklist,
+} from '../libs/util';
 import { invoiceQueue } from '../queues/invoice';
 import { paymentQueue } from '../queues/payment';
 import {
@@ -70,6 +76,7 @@ import { SetupIntent } from '../store/models/setup-intent';
 import { Subscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
 import { ensureInvoiceForCheckout } from './connect/shared';
+import { CHARGE_SUPPORTED_CHAIN_TYPES } from '../libs/constants';
 
 const router = Router();
 
@@ -692,6 +699,16 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       });
     }
 
+    // check if user in block list
+    if (CHARGE_SUPPORTED_CHAIN_TYPES.includes(paymentMethod.type)) {
+      const inBlock = await isUserInBlocklist(req.user.did, paymentMethod);
+      if (inBlock) {
+        return res
+          .status(403)
+          .json({ code: 'PAYMENT_RESTRICTED', error: 'Unable to process your purchase at this time' });
+      }
+    }
+
     await checkoutSession.update({ customer_id: customer.id, customer_did: req.user.did });
 
     // payment intent is only created when checkout session is in payment mode

package/api/tests/libs/util.spec.ts

@@ -11,8 +11,13 @@ import {
   getNextRetry,
   tryWithTimeout,
   getSubscriptionNotificationCustomActions,
+  isUserInBlocklist,
+  api,
 } from '../../src/libs/util';
-import type { Subscription } from '../../src/store/models';
+import type { Subscription, PaymentMethod } from '../../src/store/models';
+
+import { blocklet } from '../../src/libs/auth';
+import logger from '../../src/libs/logger';
 
 describe('createIdGenerator', () => {
   it('should return a function that generates an ID with the specified prefix and size', () => {
@@ -375,3 +380,276 @@ describe('getSubscriptionNotificationCustomActions', () => {
     });
   });
 });
+
+describe('isUserInBlocklist', () => {
+  let mockAxios: any;
+  let mockBlocklet: any;
+  let mockLogger: any;
+
+  beforeEach(() => {
+    mockAxios = jest.spyOn(api, 'get').mockImplementation();
+
+    mockBlocklet = jest.spyOn(blocklet, 'getUser').mockImplementation();
+
+    mockLogger = {
+      warn: jest.spyOn(logger, 'warn').mockImplementation(),
+      info: jest.spyOn(logger, 'info').mockImplementation(),
+      error: jest.spyOn(logger, 'error').mockImplementation(),
+    };
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it('should return true when user DID is in blocklist', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {
+        arcblock: {
+          api_host: 'https://api.example.com',
+        },
+      },
+    } as PaymentMethod;
+
+    mockAxios.mockResolvedValueOnce({ data: ['did:user:123', 'did:user:456'] });
+    mockBlocklet.mockResolvedValueOnce({
+      user: {
+        did: userDid,
+        connectedAccounts: [{ provider: 'wallet', did: userDid }],
+      },
+    });
+
+    // Execute
+    const result = await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify
+    expect(result).toBe(true);
+    expect(mockAxios).toHaveBeenCalledWith('https://api.example.com/blocked');
+    expect(mockBlocklet).toHaveBeenCalledWith(userDid);
+    expect(mockLogger.info).toHaveBeenCalled();
+  });
+
+  it('should return true when user wallet DID is in blocklist', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const walletDid = 'did:wallet:456';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {
+        arcblock: {
+          api_host: 'https://api.example.com',
+        },
+      },
+    } as PaymentMethod;
+
+    mockAxios.mockResolvedValueOnce({ data: ['did:wallet:456', 'did:user:789'] });
+    mockBlocklet.mockResolvedValueOnce({
+      user: {
+        did: userDid,
+        connectedAccounts: [{ provider: 'wallet', did: walletDid }],
+      },
+    });
+
+    // Execute
+    const result = await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify
+    expect(result).toBe(true);
+    expect(mockAxios).toHaveBeenCalledWith('https://api.example.com/blocked');
+    expect(mockBlocklet).toHaveBeenCalledWith(userDid);
+  });
+
+  it('should return false when user is not in blocklist', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const walletDid = 'did:wallet:456';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {
+        arcblock: {
+          api_host: 'https://api.example.com',
+        },
+      },
+    } as PaymentMethod;
+
+    mockAxios.mockResolvedValueOnce({ data: ['did:user:789', 'did:wallet:789'] });
+    mockBlocklet.mockResolvedValueOnce({
+      user: {
+        did: userDid,
+        connectedAccounts: [{ provider: 'wallet', did: walletDid }],
+      },
+    });
+
+    // Execute
+    const result = await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify
+    expect(result).toBe(false);
+    expect(mockAxios).toHaveBeenCalledWith('https://api.example.com/blocked');
+    expect(mockBlocklet).toHaveBeenCalledWith(userDid);
+  });
+
+  it('should handle API host with trailing slash', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {
+        arcblock: {
+          api_host: 'https://api.example.com/',
+        },
+      },
+    } as PaymentMethod;
+
+    mockAxios.mockResolvedValueOnce({ data: ['did:user:789'] });
+    mockBlocklet.mockResolvedValueOnce({
+      user: {
+        did: userDid,
+        connectedAccounts: [{ provider: 'wallet', did: userDid }],
+      },
+    });
+
+    // Execute
+    await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify - 确保调用了正确的 URL
+    expect(mockAxios).toHaveBeenCalledWith('https://api.example.com/blocked');
+  });
+
+  it('should return false when API host is not found', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {},
+    } as PaymentMethod;
+
+    // Execute
+    const result = await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify
+    expect(result).toBe(false);
+    expect(mockLogger.warn).toHaveBeenCalled();
+    expect(mockAxios).not.toHaveBeenCalled();
+  });
+
+  it('should return false when blocklist is empty', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {
+        arcblock: {
+          api_host: 'https://api.example.com',
+        },
+      },
+    } as PaymentMethod;
+
+    // 先模拟用户信息获取
+    mockBlocklet.mockResolvedValueOnce({
+      user: {
+        did: userDid,
+        connectedAccounts: [{ provider: 'wallet', did: userDid }],
+      },
+    });
+
+    // 再模拟空黑名单
+    mockAxios.mockResolvedValueOnce({ data: [] });
+
+    // Execute
+    const result = await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify
+    expect(result).toBe(false);
+    expect(mockBlocklet).toHaveBeenCalled(); // 现在应该调用了用户信息获取
+  });
+
+  it('should return false when user is not found', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {
+        arcblock: {
+          api_host: 'https://api.example.com',
+        },
+      },
+    } as PaymentMethod;
+
+    mockAxios.mockResolvedValueOnce({ data: ['did:user:123'] });
+    mockBlocklet.mockResolvedValueOnce({ user: null });
+
+    // Execute
+    const result = await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify
+    expect(result).toBe(false);
+    expect(mockLogger.error).toHaveBeenCalled();
+  });
+
+  it('should return false when API request fails', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {
+        arcblock: {
+          api_host: 'https://api.example.com',
+        },
+      },
+    } as PaymentMethod;
+
+    mockAxios.mockRejectedValueOnce(new Error('Network error'));
+
+    // Execute
+    const result = await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify
+    expect(result).toBe(false);
+    expect(mockLogger.error).toHaveBeenCalled();
+  });
+
+  it('should handle extraConfigs for connected accounts', async () => {
+    // Setup mocks
+    const userDid = 'did:user:123';
+    const walletDid = 'did:wallet:456';
+    const paymentMethod = {
+      id: 'pm_123',
+      type: 'arcblock',
+      settings: {
+        arcblock: {
+          api_host: 'https://api.example.com',
+        },
+      },
+    } as PaymentMethod;
+
+    mockAxios.mockResolvedValueOnce({ data: ['did:wallet:456'] });
+    mockBlocklet.mockResolvedValueOnce({
+      user: {
+        did: userDid,
+        extraConfigs: {
+          connectedAccounts: [{ provider: 'wallet', did: walletDid }],
+        },
+      },
+    });
+
+    // Execute
+    const result = await isUserInBlocklist(userDid, paymentMethod);
+
+    // Verify
+    expect(result).toBe(true);
+  });
+});

package/api/third.d.ts

@@ -40,3 +40,4 @@ namespace Express {
 }
 
 declare module 'pretty-ms-i18n';
+declare module '@blocklet/sdk/service/eventbus';

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.18.9
+version: 1.18.11
 logo: logo.png
 files:
   - dist
@@ -125,3 +125,44 @@ resource:
     - type: paywall
       description: Auto config paywall for your content
 egress: true
+events:
+  - type: checkout.session.completed
+    description: Payment checkout process has been successfully completed
+  - type: checkout.session.nft_minted
+    description: NFT has been successfully minted after payment
+  - type: customer.subscription.created
+    description: A new subscription has been successfully created
+  - type: customer.subscription.started
+    description: Subscription has been activated and billing cycle has begun
+  - type: customer.subscription.renewed
+    description: Subscription has been successfully renewed for next period
+  - type: customer.subscription.upgraded
+    description: Subscription plan has been changed to a different tier
+  - type: customer.subscription.updated
+    description: Subscription details or configuration has been modified
+  - type: customer.subscription.deleted
+    description: An existing subscription has been cancelled
+  - type: customer.subscription.renew_failed
+    description: Subscription renewal attempt has failed
+  - type: customer.subscription.trial_start
+    description: Subscription trial period has started
+  - type: customer.subscription.trial_will_end
+    description: Subscription trial period is about to end
+  - type: customer.subscription.trial_end
+    description: Subscription trial period has ended
+  - type: customer.subscription.paused
+    description: Subscription has been paused, payment collection suspended
+  - type: customer.subscription.resumed
+    description: Subscription has been resumed after being paused
+  - type: customer.subscription.past_due
+    description: Subscription payment is overdue
+  - type: customer.subscription.recovered
+    description: Subscription has been recovered from past due status
+  - type: payment_intent.succeeded
+    description: Payment has been successfully processed and confirmed
+  - type: payment_intent.payment_failed
+    description: Payment attempt has failed
+  - type: invoice.paid
+    description: Invoice has been fully paid and settled
+  - type: refund.succeeded
+    description: Refund has been successfully processed and completed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.18.9",
+  "version": "1.18.11",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -43,19 +43,19 @@
     ]
   },
   "dependencies": {
-    "@abtnode/cron": "^1.16.38",
+    "@abtnode/cron": "^1.16.39",
     "@arcblock/did": "^1.19.10",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.11.44",
+    "@arcblock/did-connect": "^2.11.48",
     "@arcblock/did-util": "^1.19.10",
     "@arcblock/jwt": "^1.19.10",
-    "@arcblock/ux": "^2.11.44",
+    "@arcblock/ux": "^2.11.48",
     "@arcblock/validator": "^1.19.10",
-    "@blocklet/js-sdk": "^1.16.38",
-    "@blocklet/logger": "^1.16.38",
-    "@blocklet/payment-react": "1.18.9",
-    "@blocklet/sdk": "^1.16.38",
-    "@blocklet/ui-react": "^2.11.44",
+    "@blocklet/js-sdk": "^1.16.39",
+    "@blocklet/logger": "^1.16.39",
+    "@blocklet/payment-react": "1.18.11",
+    "@blocklet/sdk": "^1.16.39",
+    "@blocklet/ui-react": "^2.11.48",
     "@blocklet/uploader": "^0.1.70",
     "@blocklet/xss": "^0.1.25",
     "@mui/icons-material": "^5.16.6",
@@ -119,9 +119,9 @@
     "web3": "^4.16.0"
   },
   "devDependencies": {
-    "@abtnode/types": "^1.16.38",
+    "@abtnode/types": "^1.16.39",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.18.9",
+    "@blocklet/payment-types": "1.18.11",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -151,7 +151,7 @@
     "vite": "^5.3.5",
     "vite-node": "^2.0.4",
     "vite-plugin-babel-import": "^2.0.5",
-    "vite-plugin-blocklet": "^0.9.21",
+    "vite-plugin-blocklet": "^0.9.22",
     "vite-plugin-node-polyfills": "^0.21.0",
     "vite-plugin-svgr": "^4.2.0",
     "vite-tsconfig-paths": "^4.3.2",
@@ -167,5 +167,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "e1e02357e4ef1294a788595d34b2f3e8ef6046b3"
+  "gitHead": "370cb327400359ab5972ef60316ccd7fc86c174e"
 }

package/src/global.css

@@ -71,9 +71,6 @@ th.MuiTableCell-head {
   padding-top: 16px;
 }
 
-.MuiDialogContent-root {
-  padding-top: 0px !important;
-}
 
 .MuiFormHelperText-root {
   margin-left: 0;