payment-kit 1.20.5 → 1.20.6

package/api/src/crons/index.ts

@@ -18,17 +18,19 @@ import {
   stripePaymentCronTime,
   stripeSubscriptionCronTime,
   subscriptionCronTime,
+  vendorStatusCheckCronTime,
 } from '../libs/env';
 import logger from '../libs/logger';
+import { startCreditConsumeQueue } from '../queues/credit-consume';
+import { startDepositVaultQueue } from '../queues/payment';
 import { startSubscriptionQueue } from '../queues/subscription';
+import { startVendorStatusCheckSchedule } from '../queues/vendor/vendor-status-check';
 import { CheckoutSession } from '../store/models';
+import { createMeteringSubscriptionDetection } from './metering-subscription-detection';
 import { createPaymentStat } from './payment-stat';
 import { SubscriptionTrialWillEndSchedule } from './subscription-trial-will-end';
 import { SubscriptionWillCanceledSchedule } from './subscription-will-canceled';
 import { SubscriptionWillRenewSchedule } from './subscription-will-renew';
-import { createMeteringSubscriptionDetection } from './metering-subscription-detection';
-import { startDepositVaultQueue } from '../queues/payment';
-import { startCreditConsumeQueue } from '../queues/credit-consume';
 
 function init() {
   Cron.init({
@@ -115,6 +117,12 @@ function init() {
         fn: () => startCreditConsumeQueue(),
         options: { runOnInit: true },
       },
+      {
+        name: 'vendor.status.check',
+        time: vendorStatusCheckCronTime,
+        fn: () => startVendorStatusCheckSchedule(),
+        options: { runOnInit: false },
+      },
     ],
     onError: (error: Error, name: string) => {
       logger.error('run job failed', { name, error });

package/api/src/index.ts

@@ -8,48 +8,50 @@ import cors from 'cors';
 import dotenv from 'dotenv-flow';
 import express, { ErrorRequestHandler } from 'express';
 // eslint-disable-next-line import/no-extraneous-dependencies
-import { xss } from '@blocklet/xss';
-import { csrf } from '@blocklet/sdk/lib/middlewares';
 import { CustomError, formatError, getStatusFromError } from '@blocklet/error';
+import { csrf } from '@blocklet/sdk/lib/middlewares';
+import { xss } from '@blocklet/xss';
 
+import { syncCurrencyLogo } from './crons/currency';
 import crons from './crons/index';
 import { ensureStakedForGas } from './integrations/arcblock/stake';
 import { initResourceHandler } from './integrations/blocklet/resource';
+import { initUserHandler } from './integrations/blocklet/user';
 import { ensureWebhookRegistered } from './integrations/stripe/setup';
 import { handlers } from './libs/auth';
 import logger, { setupAccessLogger } from './libs/logger';
 import { contextMiddleware, ensureI18n } from './libs/middleware';
+import { ensureCreateOverdraftProtectionPrices } from './libs/overdraft-protection';
 import { initEventBroadcast } from './libs/ws';
 import { startCheckoutSessionQueue } from './queues/checkout-session';
+import { startCreditConsumeQueue } from './queues/credit-consume';
+import { startCreditGrantQueue } from './queues/credit-grant';
 import { startEventQueue } from './queues/event';
 import { startInvoiceQueue } from './queues/invoice';
 import { startNotificationQueue } from './queues/notification';
 import { startPaymentQueue } from './queues/payment';
 import { startPayoutQueue } from './queues/payout';
 import { startRefundQueue } from './queues/refund';
+import { startUploadBillingInfoListener } from './queues/space';
 import { startSubscriptionQueue } from './queues/subscription';
-import { startCreditConsumeQueue } from './queues/credit-consume';
-import { startCreditGrantQueue } from './queues/credit-grant';
+import { startVendorCommissionQueue } from './queues/vendor/vendor-commission';
+import { startVendorFulfillmentQueue } from './queues/vendor/vendor-fulfillment';
 import routes from './routes';
+import autoRechargeAuthorizationHandlers from './routes/connect/auto-recharge-auth';
 import changePaymentHandlers from './routes/connect/change-payment';
 import changePlanHandlers from './routes/connect/change-plan';
 import collectHandlers from './routes/connect/collect';
 import collectBatchHandlers from './routes/connect/collect-batch';
-import rechargeHandlers from './routes/connect/recharge';
-import payHandlers from './routes/connect/pay';
-import setupHandlers from './routes/connect/setup';
-import subscribeHandlers from './routes/connect/subscribe';
 import delegationHandlers from './routes/connect/delegation';
 import overdraftProtectionHandlers from './routes/connect/overdraft-protection';
-import rechargeAccountHandlers from './routes/connect/recharge-account';
+import payHandlers from './routes/connect/pay';
 import reStakeHandlers from './routes/connect/re-stake';
-import autoRechargeAuthorizationHandlers from './routes/connect/auto-recharge-auth';
+import rechargeHandlers from './routes/connect/recharge';
+import rechargeAccountHandlers from './routes/connect/recharge-account';
+import setupHandlers from './routes/connect/setup';
+import subscribeHandlers from './routes/connect/subscribe';
 import { initialize } from './store/models';
 import { sequelize } from './store/sequelize';
-import { initUserHandler } from './integrations/blocklet/user';
-import { startUploadBillingInfoListener } from './queues/space';
-import { syncCurrencyLogo } from './crons/currency';
-import { ensureCreateOverdraftProtectionPrices } from './libs/overdraft-protection';
 
 dotenv.config();
 
@@ -126,6 +128,8 @@ export const server = app.listen(port, (err?: any) => {
   startSubscriptionQueue().then(() => logger.info('subscription queue started'));
   startEventQueue().then(() => logger.info('event queue started'));
   startPayoutQueue().then(() => logger.info('payout queue started'));
+  startVendorCommissionQueue().then(() => logger.info('vendor commission queue started'));
+  startVendorFulfillmentQueue().then(() => logger.info('vendor fulfillment queue started'));
   startCheckoutSessionQueue().then(() => logger.info('checkoutSession queue started'));
   startNotificationQueue().then(() => logger.info('notification queue started'));
   startRefundQueue().then(() => logger.info('refund queue started'));

package/api/src/libs/adapters/launcher-adapter.ts

@@ -0,0 +1,177 @@
+import { VendorAuth } from '@blocklet/payment-vendor';
+
+import {
+  VendorAdapter,
+  VendorConfig,
+  FulfillOrderParams,
+  FulfillOrderResult,
+  ReturnRequestParams,
+  ReturnRequestResult,
+  CheckOrderStatusParams,
+  CheckOrderStatusResult,
+} from '../vendor-adapter';
+import logger from '../logger';
+import { ProductVendor } from '../../store/models';
+import { api } from '../util';
+
+export class LauncherAdapter implements VendorAdapter {
+  private vendorConfig: VendorConfig | null = null;
+  private vendorKey: string;
+
+  constructor(vendorInfo: VendorConfig | string) {
+    if (typeof vendorInfo === 'string') {
+      this.vendorKey = vendorInfo;
+      this.vendorConfig = null;
+    } else {
+      this.vendorKey = vendorInfo.id;
+      this.vendorConfig = vendorInfo;
+    }
+  }
+
+  async getVendorConfig(): Promise<VendorConfig> {
+    if (this.vendorConfig === null) {
+      this.vendorConfig = await ProductVendor.findOne({ where: { vendor_key: this.vendorKey } });
+      if (!this.vendorConfig) {
+        throw new Error(`Vendor not found: ${this.vendorKey}`);
+      }
+    }
+    return this.vendorConfig;
+  }
+
+  async fulfillOrder(params: FulfillOrderParams): Promise<FulfillOrderResult> {
+    logger.info('Creating launcher order via real API', {
+      productCode: params.productCode,
+      customerId: params.customerId,
+      description: params.description,
+    });
+
+    const vendorConfig = await this.getVendorConfig();
+
+    try {
+      const launcherApiUrl = vendorConfig.app_url;
+      const orderData = {
+        description: params.description,
+        userInfo: params.userInfo,
+        deliveryParams: params.deliveryParams,
+      };
+
+      const { headers, body } = VendorAuth.signRequestWithHeaders(orderData);
+      const response = await fetch(`${launcherApiUrl}/api/vendor/deliveries`, {
+        method: 'POST',
+        headers,
+        body,
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text();
+        logger.error('Launcher API error', {
+          status: response.status,
+          statusText: response.statusText,
+          body: errorBody,
+        });
+        throw new Error(`Launcher API error: ${response.status} ${response.statusText}`);
+      }
+
+      const launcherResult = await response.json();
+
+      const result: FulfillOrderResult = {
+        orderId: launcherResult.orderId || launcherResult.vendorOrderId || `launcher_${Date.now()}`,
+        status: launcherResult.status || 'pending',
+        serviceUrl: launcherResult.serviceUrl || launcherResult.appUrl,
+        estimatedTime: launcherResult.estimatedTime || 300,
+        message: launcherResult.message || 'Launcher order created successfully',
+        vendorOrderId: launcherResult.vendorOrderId || launcherResult.orderId,
+        progress: launcherResult.progress || 0,
+        orderDetails: {
+          productCode: params.productCode,
+          customerId: params.customerId,
+          amount: params.amount,
+          currency: params.currency,
+          quantity: params.quantity,
+          paymentIntentId: params.paymentIntentId,
+          customParams: params.customParams,
+        },
+        installationInfo: {
+          appId: launcherResult.appId,
+          appUrl: launcherResult.appUrl,
+          adminUrl: launcherResult.adminUrl,
+          status: launcherResult.installationStatus || launcherResult.status,
+          estimatedCompletionTime: launcherResult.estimatedCompletionTime,
+        },
+      };
+
+      logger.info('Launcher order created successfully', {
+        orderId: result.orderId,
+        status: result.status,
+        serviceUrl: result.serviceUrl,
+      });
+
+      return result;
+    } catch (error: any) {
+      logger.error('Failed to create launcher order', {
+        error: error.message,
+        productCode: params.productCode,
+        customerId: params.customerId,
+      });
+
+      throw error;
+    }
+  }
+
+  async requestReturn(params: ReturnRequestParams): Promise<ReturnRequestResult> {
+    logger.debug('Requesting return for Launcher order', {
+      orderId: params.orderId,
+      reason: params.reason,
+    });
+
+    const vendorConfig = await this.getVendorConfig();
+    const launcherApiUrl = vendorConfig.app_url;
+    const { headers, body } = VendorAuth.signRequestWithHeaders(params);
+
+    const response = await fetch(`${launcherApiUrl}/api/vendor/return`, {
+      method: 'POST',
+      headers,
+      body,
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      logger.error('Launcher API error', {
+        status: response.status,
+        statusText: response.statusText,
+        body: errorBody,
+      });
+      throw new Error(`Launcher API error: ${response.status} ${response.statusText}`);
+    }
+
+    const launcherResult = await response.json();
+
+    return launcherResult;
+  }
+
+  async checkOrderStatus(params: CheckOrderStatusParams): Promise<CheckOrderStatusResult> {
+    const url = `${params.appUrl}/__blocklet__.js?type=json&noCache=1`;
+    try {
+      const blocklet = await api.get(url, {
+        headers: { 'Content-Type': 'application/json' },
+      });
+      const blockletInfo = blocklet.data;
+      let status: 'processing' | 'completed' | 'failed' = 'processing';
+      if (blockletInfo.status === 'running') {
+        status = 'completed';
+      } else if (blockletInfo.status === 'failed') {
+        status = 'failed';
+      }
+
+      return { status };
+    } catch (error: any) {
+      logger.error('Failed to check order status', {
+        url,
+        error: error.message,
+        stack: error.stack,
+      });
+
+      throw error;
+    }
+  }
+}

package/api/src/libs/env.ts

@@ -14,6 +14,13 @@ export const meteringSubscriptionDetectionCronTime: string =
   process.env.METERING_SUBSCRIPTION_DETECTION_CRON_TIME || '0 0 10 * * *'; // 默认每天 10:00 执行
 export const depositVaultCronTime: string = process.env.DEPOSIT_VAULT_CRON_TIME || '0 */5 * * * *'; // 默认每 5 min 执行一次
 export const creditConsumptionCronTime: string = process.env.CREDIT_CONSUMPTION_CRON_TIME || '0 */10 * * * *'; // 默认每 10 min 执行一次
+export const vendorStatusCheckCronTime: string = process.env.VENDOR_STATUS_CHECK_CRON_TIME || '0 */10 * * * *'; // 默认每 10 min 执行一次
+export const vendorTimeoutMinutes: number = process.env.VENDOR_TIMEOUT_MINUTES
+  ? +process.env.VENDOR_TIMEOUT_MINUTES
+  : 10; // 默认 10 分钟超时
+
+export const shortUrlApiKey: string = process.env.SHORT_URL_API_KEY || '';
+
 // sequelize 配置相关
 export const sequelizeOptionsPoolMin: number = process.env.SEQUELIZE_OPTIONS_POOL_MIN
   ? +process.env.SEQUELIZE_OPTIONS_POOL_MIN

package/api/src/libs/url.ts

@@ -0,0 +1,77 @@
+import logger from './logger';
+import { shortUrlApiKey } from './env';
+
+interface ShortUrlResponse {
+  shortUrl: string;
+  longUrl: string;
+  shortCode: string;
+  dateCreated: string;
+}
+
+interface ShortUrlRequest {
+  longUrl: string;
+  validUntil?: string;
+  maxVisits?: number;
+  tags?: string[];
+  shortCodeLength?: number;
+  domain?: string;
+  findIfExists?: boolean;
+  validateUrl?: boolean;
+  forwardQuery?: boolean;
+  crawlable?: boolean;
+}
+
+export async function formatToShortUrl({
+  url,
+  validUntil,
+  maxVisits,
+}: {
+  url: string;
+  validUntil?: string;
+  maxVisits?: number;
+}): Promise<string> {
+  const apiKey = shortUrlApiKey;
+
+  if (!apiKey) {
+    return url;
+  }
+
+  try {
+    const requestPayload: ShortUrlRequest = {
+      longUrl: url,
+      validUntil,
+      maxVisits,
+      tags: [],
+      shortCodeLength: 8,
+      domain: 's.abtnet.io',
+      findIfExists: true,
+      validateUrl: true,
+      forwardQuery: true,
+      crawlable: true,
+    };
+
+    const response = await fetch('https://s.abtnet.io/rest/v3/short-urls', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Api-Key': apiKey,
+      },
+      body: JSON.stringify(requestPayload),
+    });
+
+    if (!response.ok) {
+      logger.warn('Failed to create short URL, using original URL', {
+        status: response.status,
+        statusText: response.statusText,
+        url,
+      });
+      return url;
+    }
+
+    const data: ShortUrlResponse = await response.json();
+    return data.shortUrl;
+  } catch (error) {
+    logger.error('Error creating short URL, using original URL', { error, url });
+    return url;
+  }
+}

package/api/src/libs/vendor-adapter-factory.ts

@@ -0,0 +1,22 @@
+import { VendorAdapter, VendorConfig } from './vendor-adapter';
+import { LauncherAdapter } from './adapters/launcher-adapter.js';
+
+export class VendorAdapterFactory {
+  static create(vendorConfig: string | VendorConfig): VendorAdapter {
+    const vendorKey = typeof vendorConfig === 'string' ? vendorConfig : vendorConfig.vendor_key;
+    switch (vendorKey) {
+      case 'launcher':
+        return new LauncherAdapter(vendorConfig);
+      default:
+        throw new Error(`Unsupported vendor: ${vendorConfig}`);
+    }
+  }
+
+  static getSupportedVendors(): string[] {
+    return ['launcher'];
+  }
+
+  static isSupported(vendorKey: string): boolean {
+    return this.getSupportedVendors().includes(vendorKey);
+  }
+}

package/api/src/libs/vendor-adapter.ts

@@ -0,0 +1,109 @@
+import { BN } from '@ocap/util';
+
+export interface VendorConfig {
+  id: string;
+  vendor_key: string;
+  name: string;
+  description: string;
+  app_url: string;
+  webhook_path?: string;
+  default_commission_rate: number;
+  default_commission_type: 'percentage' | 'fixed_amount';
+  order_create_params: Record<string, any>;
+  status: 'active' | 'inactive';
+  metadata: Record<string, any>;
+}
+
+export interface FulfillOrderParams {
+  productCode: string;
+  customerId: string;
+  quantity: number;
+  paymentIntentId: string;
+  amount: string;
+  currency: string;
+
+  description: string;
+  userInfo: {
+    userDid: string;
+    email: string;
+    description?: string;
+  };
+  deliveryParams: {
+    blockletMetaUrl: string;
+    customParams?: Record<string, any>;
+  };
+
+  customParams?: Record<string, any>;
+}
+
+export interface OrderDetails {
+  productCode: string;
+  customerId: string;
+  amount: string;
+  currency: string;
+  quantity: number;
+  paymentIntentId: string;
+  customParams?: Record<string, any>;
+}
+
+export interface InstallationInfo {
+  appId: string;
+  appUrl: string;
+  adminUrl: string;
+  status: 'installing' | 'completed' | 'failed';
+  estimatedCompletionTime: string;
+}
+
+export interface FulfillOrderResult {
+  orderId: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  serviceUrl?: string;
+  estimatedTime?: number;
+  message: string;
+  vendorOrderId?: string;
+  progress?: number;
+  orderDetails?: OrderDetails;
+  installationInfo?: InstallationInfo;
+}
+
+export interface ReturnRequestParams {
+  orderId: string;
+  vendorOrderId?: string;
+  reason: string;
+  paymentIntentId: string;
+  customParams?: Record<string, any>;
+}
+
+export interface ReturnRequestResult {
+  status: 'requested' | 'accepted' | 'rejected' | 'failed';
+  message?: string;
+}
+
+export interface CheckOrderStatusParams extends Record<string, any> {}
+
+export interface CheckOrderStatusResult {
+  status: 'processing' | 'completed' | 'failed';
+}
+
+export interface VendorAdapter {
+  fulfillOrder(params: FulfillOrderParams): Promise<FulfillOrderResult>;
+  requestReturn(params: ReturnRequestParams): Promise<ReturnRequestResult>;
+  checkOrderStatus(params: CheckOrderStatusParams): Promise<CheckOrderStatusResult>;
+}
+
+export function calculateVendorCommission(
+  totalAmount: string,
+  commissionRate: number,
+  commissionType: 'percentage' | 'fixed_amount',
+  itemAmount?: string
+): string {
+  const amount = itemAmount || totalAmount || '0';
+
+  if (commissionType === 'percentage') {
+    return new BN(amount)
+      .mul(new BN(commissionRate || 0))
+      .div(new BN(100))
+      .toString();
+  }
+  return new BN(commissionRate).toString();
+}