payment-kit 1.20.17 → 1.20.19

package/.env

@@ -1 +1,2 @@
 COMPONENT_STORE_URL="https://test.store.blocklet.dev"
+LOG_LEVEL=debug

package/api/src/index.ts

@@ -37,6 +37,7 @@ import { startUploadBillingInfoListener } from './queues/space';
 import { startSubscriptionQueue } from './queues/subscription';
 import { startVendorCommissionQueue } from './queues/vendors/commission';
 import { startVendorFulfillmentQueue } from './queues/vendors/fulfillment';
+import { startCoordinatedFulfillmentQueue } from './queues/vendors/fulfillment-coordinator';
 import routes from './routes';
 import autoRechargeAuthorizationHandlers from './routes/connect/auto-recharge-auth';
 import changePaymentHandlers from './routes/connect/change-payment';
@@ -131,6 +132,7 @@ export const server = app.listen(port, (err?: any) => {
   startPayoutQueue().then(() => logger.info('payout queue started'));
   startVendorCommissionQueue().then(() => logger.info('vendor commission queue started'));
   startVendorFulfillmentQueue().then(() => logger.info('vendor fulfillment queue started'));
+  startCoordinatedFulfillmentQueue().then(() => logger.info('coordinated 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/vendor-util/adapters/didnames-adapter.ts

@@ -0,0 +1,412 @@
+import { VendorAuth } from '@blocklet/payment-vendor';
+import { toBase58 } from '@ocap/util';
+import stableStringify from 'json-stable-stringify';
+import { v4 as uuidV4 } from 'uuid';
+
+import { ProductVendor } from '../../../store/models';
+import { wallet } from '../../auth';
+import logger from '../../logger';
+import {
+  CheckOrderStatusParams,
+  CheckOrderStatusResult,
+  FulfillOrderParams,
+  FulfillOrderResult,
+  ReturnRequestParams,
+  ReturnRequestResult,
+  VendorAdapter,
+  VendorConfig,
+} from './types';
+import { formatVendorUrl } from './util';
+
+export class DidnamesAdapter 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;
+    }
+  }
+
+  /**
+   * Generate random subdomain for documentation site
+   * Format: [prefix][separator][timestamp-suffix] or pure timestamp
+   * Configurable length, prefix, separator with timestamp-based uniqueness
+   */
+  private generateRandomSubdomain(
+    options: {
+      totalLength?: number; // Total subdomain length (default: 9)
+      prefix?: string; // Prefix (default: 'doc')
+      usePrefix?: boolean; // Whether to use prefix (default: true)
+      separator?: string; // Separator between prefix and suffix (default: '-')
+    } = {}
+  ): string {
+    const { totalLength = 8, prefix = 'doc', usePrefix = true, separator = '-' } = options;
+
+    if (usePrefix) {
+      // With prefix: 'doc' + separator + timestamp suffix
+      const prefixWithSeparatorLength = prefix.length + separator.length;
+      const suffixLength = totalLength - prefixWithSeparatorLength;
+      if (suffixLength <= 0) {
+        throw new Error(
+          `Total length (${totalLength}) must be greater than prefix + separator length (${prefixWithSeparatorLength})`
+        );
+      }
+
+      const timestamp = Date.now();
+      const timeStr = timestamp.toString(36);
+      let suffix = timeStr.slice(-suffixLength);
+
+      // Pad with random chars if timestamp is shorter than needed
+      while (suffix.length < suffixLength) {
+        suffix = Math.floor(Math.random() * 36).toString(36) + suffix;
+      }
+
+      return `${prefix}${separator}${suffix}`;
+    }
+
+    // Pure timestamp-based without prefix
+    const timestamp = Date.now();
+    const timeStr = timestamp.toString(36);
+    let result = timeStr.slice(-totalLength);
+
+    // Pad with random chars if needed
+    while (result.length < totalLength) {
+      result = Math.floor(Math.random() * 36).toString(36) + result;
+    }
+
+    return result;
+  }
+
+  /**
+   * Generate bindDomainCap (binding capability) for domain authorization
+   */
+  private generateBindCap({ domain, checkoutSessionId }: { domain: string; checkoutSessionId: string }): any {
+    const now = Math.floor(Date.now() / 1000);
+    const expireInMinutes = 30;
+
+    const cap = {
+      domain,
+      checkoutSessionId,
+      nbf: now, // not before
+      exp: now + expireInMinutes * 60,
+      nonce: uuidV4(),
+    };
+
+    const signature = toBase58(wallet.sign(stableStringify(cap) || ''));
+
+    return {
+      cap,
+      sig: signature,
+    };
+  }
+
+  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 didnames order with domain binding', {
+      checkoutSessionId: params.checkoutSessionId,
+      productCode: params.productCode,
+      customerId: params.customerId,
+    });
+
+    const vendorConfig = await this.getVendorConfig();
+
+    try {
+      const rootDomain = vendorConfig.metadata?.rootDomain;
+      if (!rootDomain) {
+        throw new Error('missing required metadata in didnames vendor: rootDomain');
+      }
+
+      logger.info('didnames vendor rootDomain', { rootDomain });
+
+      const subdomain = this.generateRandomSubdomain({ totalLength: 8 });
+      const domain = `${subdomain}.${rootDomain}`;
+
+      const { checkoutSessionId } = params;
+      const bindDomainCap = this.generateBindCap({
+        domain,
+        checkoutSessionId,
+      });
+
+      params.deliveryParams.customParams = {
+        ...params.deliveryParams.customParams,
+        years: 1,
+        whoisPrivacy: true,
+        subdomain,
+        rootDomain,
+        domain,
+        checkoutSessionId,
+        bindDomainCap,
+      };
+
+      const orderData = {
+        checkoutSessionId: params.checkoutSessionId,
+        description: params.description,
+        userInfo: params.userInfo,
+        deliveryParams: params.deliveryParams,
+      };
+
+      const url = formatVendorUrl(vendorConfig, '/api/vendor/deliveries');
+      logger.info('submitting domain delivery to DID Names', {
+        subdomain,
+        url,
+      });
+
+      const { headers, body } = VendorAuth.signRequestWithHeaders(orderData);
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body,
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text();
+        logger.error('DID Names API error', {
+          url,
+          status: response.status,
+          statusText: response.statusText,
+          body: errorBody,
+        });
+        throw new Error(`DID Names API error: ${response.status} ${response.statusText}`);
+      }
+
+      const didNamesResult = await response.json();
+
+      const result: FulfillOrderResult = {
+        orderId: didNamesResult.orderId,
+        status: didNamesResult.status || 'pending',
+        serviceUrl: `https://${subdomain}.${rootDomain}`, // User expects to access via custom domain
+        estimatedTime: didNamesResult.estimatedTime || 300,
+        message: didNamesResult.message || 'Domain binding order created successfully',
+        vendorOrderId: didNamesResult.orderId,
+        progress: didNamesResult.progress || 0,
+        orderDetails: {
+          productCode: params.productCode,
+          customerId: params.customerId,
+          amount: params.amount,
+          currency: params.currency,
+          quantity: params.quantity,
+          invoiceId: params.invoiceId,
+          customParams: {
+            ...params.customParams,
+            subdomain,
+            rootDomain,
+            domain: didNamesResult.domain || domain,
+            nftDid: didNamesResult.nftDid,
+            sessionId: params.customParams?.checkoutSessionId,
+            bindDomainCap,
+          },
+        },
+        installationInfo: {
+          appId: didNamesResult.appId || `app_${subdomain.replace(/\./g, '_')}`,
+          appUrl: `https://${subdomain}.${rootDomain}`, // Custom domain URL
+          adminUrl: didNamesResult.adminUrl || `https://${subdomain}.${rootDomain}/admin`,
+          status: didNamesResult.installationStatus || didNamesResult.status || 'installing',
+          estimatedCompletionTime:
+            didNamesResult.estimatedCompletionTime || new Date(Date.now() + 300000).toISOString(),
+        },
+      };
+
+      logger.info('Didnames order created successfully', {
+        orderId: result.orderId,
+        status: result.status,
+        subdomain,
+        serviceUrl: result.serviceUrl,
+      });
+
+      return result;
+    } catch (error: any) {
+      logger.error('Failed to create didnames order', {
+        error,
+        productCode: params.productCode,
+        customerId: params.customerId,
+      });
+
+      throw error;
+    }
+  }
+
+  async requestReturn(params: ReturnRequestParams): Promise<ReturnRequestResult> {
+    logger.info('Requesting return for Didnames order', {
+      orderId: params.orderId,
+      reason: params.reason,
+    });
+
+    const vendorConfig = await this.getVendorConfig();
+
+    try {
+      const returnRequest = {
+        orderId: params.orderId,
+        vendorOrderId: params.vendorOrderId,
+        reason: params.reason,
+        customParams: params.customParams,
+      };
+
+      const { headers, body } = VendorAuth.signRequestWithHeaders(returnRequest);
+      const url = formatVendorUrl(vendorConfig, '/api/vendor/return');
+      logger.info('submitting domain return to DID Names', {
+        url,
+      });
+      const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body,
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text();
+        logger.error('domain return to DID Names API error', {
+          url,
+          status: response.status,
+          statusText: response.statusText,
+          body: errorBody,
+        });
+        throw new Error(`DID Names API error: ${response.status} ${response.statusText}`);
+      }
+
+      const didNamesResult = await response.json();
+
+      logger.info('domain return to DID Names processed', {
+        url,
+        orderId: params.orderId,
+        status: didNamesResult.status,
+      });
+
+      return {
+        status: didNamesResult.status || 'requested',
+        message: didNamesResult.message || 'Domain unbinding requested',
+      };
+    } catch (error: any) {
+      logger.error('Failed to process return request', {
+        error: error.message,
+        orderId: params.orderId,
+      });
+
+      throw error;
+    }
+  }
+
+  async checkOrderStatus(params: CheckOrderStatusParams): Promise<CheckOrderStatusResult> {
+    logger.info('Checking Didnames order status', {
+      orderId: params.orderId,
+    });
+
+    try {
+      const vendorConfig = await this.getVendorConfig();
+      const url = formatVendorUrl(vendorConfig, `/api/vendor/orders/${params.orderId}/status`);
+
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (!response.ok) {
+        logger.warn('DID Names order status check failed', {
+          orderId: params.orderId,
+          status: response.status,
+        });
+        return { status: 'processing' };
+      }
+
+      const orderStatus = await response.json();
+      let status: 'processing' | 'completed' | 'failed' = 'processing';
+
+      switch (orderStatus.status) {
+        case 'completed':
+        case 'active':
+        case 'failed':
+        case 'rejected':
+        case 'error':
+          status = 'failed';
+          break;
+        default:
+          status = 'processing';
+      }
+
+      logger.info('Didnames order status checked', {
+        orderId: params.orderId,
+        status,
+        didNamesStatus: orderStatus.status,
+        domain: params.domain,
+      });
+
+      return { status };
+    } catch (error: any) {
+      logger.error('Failed to check didnames order status', {
+        error: error.message,
+        orderId: params.orderId,
+      });
+
+      throw error;
+    }
+  }
+
+  async getOrder(vendor: ProductVendor, orderId: string): Promise<any> {
+    const url = formatVendorUrl(vendor, `/api/vendor/orders/${orderId}`);
+
+    const { headers } = VendorAuth.signRequestWithHeaders({});
+    const response = await fetch(url, { method: 'GET', headers });
+
+    if (!response.ok) {
+      logger.error('Failed to get didnames order', {
+        url,
+        orderId,
+        status: response.status,
+        statusText: response.statusText,
+      });
+      throw new Error(`Failed to get order: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  }
+
+  async getOrderStatus(vendor: ProductVendor, orderId: string): Promise<any> {
+    const url = formatVendorUrl(vendor, `/api/vendor/status/${orderId}`);
+
+    logger.info('getting didnames order status', {
+      url,
+      orderId,
+    });
+
+    const { headers } = VendorAuth.signRequestWithHeaders({});
+    const response = await fetch(url, { method: 'GET', headers });
+
+    logger.info('didnames order status response', {
+      url,
+      orderId,
+      status: response.status,
+      statusText: response.statusText,
+    });
+
+    if (!response.ok) {
+      logger.error('Failed to get didnames order status', {
+        url,
+        orderId,
+        status: response.status,
+        statusText: response.statusText,
+      });
+      throw new Error(`Failed to get order status: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+
+    return data;
+  }
+}

package/api/src/libs/vendor-util/adapters/factory.ts

@@ -1,4 +1,6 @@
 import { BN } from '@ocap/util';
+
+import { DidnamesAdapter } from './didnames-adapter';
 import { LauncherAdapter } from './launcher-adapter';
 import { VendorAdapter } from './types';
 import { ProductVendor } from '../../../store/models';
@@ -26,16 +28,39 @@ export class VendorAdapterFactory {
     if (!vendorConfig) {
       throw new Error(`Vendor not found: ${vendorKey}`);
     }
+
     switch (vendorConfig.vendor_type) {
       case 'launcher':
         return new LauncherAdapter(vendorConfig);
+      case 'didnames':
+        return new DidnamesAdapter(vendorConfig);
       default:
         throw new Error(`Unsupported vendor: ${vendorConfig.vendor_type}`);
     }
   }
 
+  /**
+   * Create coordinated adapters for domain binding workflow
+   * @param vendorKeys Array of vendor keys in execution order
+   */
+  static async createCoordinated(vendorKeys: string[]): Promise<{
+    didnamesAdapter?: DidnamesAdapter;
+    launcherAdapter?: LauncherAdapter;
+  }> {
+    const adapters: { [key: string]: VendorAdapter } = {};
+
+    for (const vendorKey of vendorKeys) {
+      adapters[vendorKey] = await this.create(vendorKey); // eslint-disable-line no-await-in-loop
+    }
+
+    return {
+      didnamesAdapter: adapters.didnames as DidnamesAdapter,
+      launcherAdapter: adapters.launcher as LauncherAdapter,
+    };
+  }
+
   static getSupportedVendors(): string[] {
-    return ['launcher'];
+    return ['launcher', 'didnames'];
   }
 
   static isSupported(vendorKey: string): boolean {

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

@@ -1,8 +1,9 @@
 import { Auth as VendorAuth } from '@blocklet/payment-vendor';
 
-import { joinURL } from 'ufo';
 import { ProductVendor } from '../../../store/models';
+import dayjs from '../../dayjs';
 import logger from '../../logger';
+import { formatToShortUrl } from '../../url';
 import { api } from '../../util';
 import {
   CheckOrderStatusParams,
@@ -14,6 +15,51 @@ import {
   VendorAdapter,
   VendorConfig,
 } from './types';
+import { formatVendorUrl } from './util';
+
+const doRequestVendorData = (vendor: ProductVendor, orderId: string, url: string) => {
+  const { headers } = VendorAuth.signRequestWithHeaders({});
+  const name = vendor?.name;
+  const key = vendor?.vendor_key;
+
+  return fetch(url, { headers })
+    .then(async (r) => {
+      const data = await r.json();
+      if (r.status !== 200) {
+        logger.error('vendor status fetch failed', {
+          vendorId: vendor.id,
+          vendorKey: vendor.vendor_key,
+          orderId,
+          status: r.status,
+          url,
+          data,
+        });
+        throw new Error(
+          `vendor status fetch failed, vendor: ${vendor.vendor_key}, orderId: ${orderId}, status: ${r.status}, url: ${url}`
+        );
+      }
+      if (!data.dashboardUrl) {
+        return {
+          ...data,
+          name,
+          key,
+        };
+      }
+
+      const validUntil = dayjs().add(20, 'minutes').format('YYYY-MM-DDTHH:mm:ss+00:00');
+      const maxVisits = 5;
+      const homeUrl = await formatToShortUrl({ url: data.homeUrl, maxVisits, validUntil });
+      const dashboardUrl = await formatToShortUrl({ url: data.dashboardUrl, maxVisits, validUntil });
+      return {
+        ...data,
+        name,
+        key,
+        homeUrl,
+        dashboardUrl,
+      };
+    })
+    .catch((e) => ({ error: e.message }));
+};
 
 export class LauncherAdapter implements VendorAdapter {
   private vendorConfig: VendorConfig | null = null;
@@ -40,12 +86,12 @@ export class LauncherAdapter implements VendorAdapter {
       productCode: params.productCode,
       customerId: params.customerId,
       description: params.description,
+      bindCapInfo: params.deliveryParams?.customParams?.bindDomainCap ? 'present' : 'not present',
     });
 
     const vendorConfig = await this.getVendorConfig();
 
     try {
-      const launcherApiUrl = vendorConfig.app_url;
       const orderData = {
         checkoutSessionId: params.checkoutSessionId,
         description: params.description,
@@ -53,19 +99,42 @@ export class LauncherAdapter implements VendorAdapter {
         deliveryParams: params.deliveryParams,
       };
 
+      // Extract bindDomainCap related params if present
+      const customParams = params.deliveryParams?.customParams || {};
+      const { domain, sessionId, bindDomainCap, domainNftDid } = customParams;
+
+      if (bindDomainCap && domain && sessionId) {
+        logger.info('passing domain binding authorization to Blocklet Server', {
+          domain,
+          sessionId: `${sessionId.substring(0, 8)}...`, // Log partial sessionId for security
+          hasBindCap: true,
+        });
+
+        // Ensure bindDomainCap data is passed through to Blocklet Server
+        orderData.deliveryParams = {
+          ...orderData.deliveryParams,
+          customParams: {
+            ...orderData.deliveryParams.customParams,
+            domain,
+            sessionId,
+            bindDomainCap,
+            domainNftDid,
+          },
+        };
+      }
+
       const { headers, body } = VendorAuth.signRequestWithHeaders(orderData);
-      const response = await fetch(
-        joinURL(launcherApiUrl, vendorConfig.metadata?.mountPoint || '', '/api/vendor/deliveries'),
-        {
-          method: 'POST',
-          headers,
-          body,
-        }
-      );
+      const url = formatVendorUrl(vendorConfig, '/api/vendor/deliveries');
+      const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body,
+      });
 
       if (!response.ok) {
         const errorBody = await response.text();
-        logger.error('Launcher API error', {
+        logger.error('call launcher API error', {
+          url,
           status: response.status,
           statusText: response.statusText,
           body: errorBody,
@@ -90,7 +159,18 @@ export class LauncherAdapter implements VendorAdapter {
           currency: params.currency,
           quantity: params.quantity,
           invoiceId: params.invoiceId,
-          customParams: params.customParams,
+          customParams: {
+            ...params.customParams,
+            // Include domain binding info if available
+            ...(customParams.bindDomainCap
+              ? {
+                  domain: customParams.domain,
+                  sessionId: customParams.sessionId,
+                  bindDomainCap: customParams.bindDomainCap,
+                  domainNftDid: customParams.domainNftDid,
+                }
+              : {}),
+          },
         },
         installationInfo: {
           appId: launcherResult.appId,
@@ -110,7 +190,7 @@ export class LauncherAdapter implements VendorAdapter {
       return result;
     } catch (error: any) {
       logger.error('Failed to create launcher order', {
-        error: error.message,
+        error,
         productCode: params.productCode,
         customerId: params.customerId,
       });
@@ -126,17 +206,13 @@ export class LauncherAdapter implements VendorAdapter {
     });
 
     const vendorConfig = await this.getVendorConfig();
-    const launcherApiUrl = vendorConfig.app_url;
     const { headers, body } = VendorAuth.signRequestWithHeaders(params);
 
-    const response = await fetch(
-      joinURL(launcherApiUrl, vendorConfig.metadata?.mountPoint || '', '/api/vendor/return'),
-      {
-        method: 'POST',
-        headers,
-        body,
-      }
-    );
+    const response = await fetch(formatVendorUrl(vendorConfig, '/api/vendor/return'), {
+      method: 'POST',
+      headers,
+      body,
+    });
 
     if (!response.ok) {
       const errorBody = await response.text();
@@ -178,4 +254,16 @@ export class LauncherAdapter implements VendorAdapter {
       throw error;
     }
   }
+
+  getOrderStatus(vendor: ProductVendor, orderId: string): Promise<any> {
+    const url = formatVendorUrl(vendor, `/api/vendor/status/${orderId}`);
+
+    return doRequestVendorData(vendor, orderId, url);
+  }
+
+  getOrder(vendor: ProductVendor, orderId: string): Promise<any> {
+    const url = formatVendorUrl(vendor, `/api/vendor/orders/${orderId}`);
+
+    return doRequestVendorData(vendor, orderId, url);
+  }
 }

package/api/src/libs/vendor-util/adapters/types.ts

@@ -1,3 +1,5 @@
+import type { ProductVendor } from '../../../store/models';
+
 export interface VendorConfig {
   id: string;
   vendor_key: string;
@@ -85,4 +87,6 @@ export interface VendorAdapter {
   fulfillOrder(params: FulfillOrderParams): Promise<FulfillOrderResult>;
   requestReturn(params: ReturnRequestParams): Promise<ReturnRequestResult>;
   checkOrderStatus(params: CheckOrderStatusParams): Promise<CheckOrderStatusResult>;
+  getOrder(vendor: ProductVendor, orderId: string): Promise<any>;
+  getOrderStatus(vendor: ProductVendor, orderId: string): Promise<any>;
 }

package/api/src/libs/vendor-util/adapters/util.ts

@@ -0,0 +1,7 @@
+import { joinURL } from 'ufo';
+
+import type { VendorConfig } from './types';
+
+export const formatVendorUrl = (vendorConfig: VendorConfig, p: string) => {
+  return joinURL(vendorConfig.app_url, vendorConfig.metadata?.mountPoint || '', p);
+};