payment-kit 1.21.8 → 1.21.10

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

@@ -18,6 +18,44 @@ import {
 } from './types';
 import { formatVendorUrl } from './util';
 
+const DOMAIN_CONFLICT_ERROR_CODE = 'ERROR_DOMAIN_NOT_AVAILABLE';
+
+export const parseDomainLength = (len: number | string | undefined, defaultValue: number) => {
+  try {
+    if (len === undefined) {
+      return defaultValue;
+    }
+
+    if (typeof len === 'number') {
+      return len;
+    }
+
+    return parseInt(len, 10) || defaultValue;
+  } catch (error) {
+    logger.error('failed to parse domain length', {
+      error,
+      len,
+      defaultValue,
+    });
+
+    return defaultValue;
+  }
+};
+
+export const generateRandomSubdomain = (totalLength: number = 8): string => {
+  // Generate timestamp-based string for uniqueness
+  const timestamp = Date.now();
+  const timeStr = timestamp.toString(36);
+  let result = timeStr.slice(-Math.min(timeStr.length, totalLength));
+
+  // Pad with random chars if needed
+  while (result.length < totalLength) {
+    result = Math.floor(Math.random() * 36).toString(36) + result;
+  }
+
+  return result.slice(0, totalLength);
+};
+
 export class DidnamesAdapter implements VendorAdapter {
   private vendorConfig: VendorConfig | null = null;
   private vendorKey: string;
@@ -33,53 +71,128 @@ export class DidnamesAdapter implements VendorAdapter {
   }
 
   /**
-   * Generate random subdomain for documentation site
-   * Format: [prefix][separator][timestamp-suffix] or pure timestamp
-   * Configurable length, prefix, separator with timestamp-based uniqueness
+   * Submit domain order with retry logic for domain conflicts
    */
-  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})`
-        );
-      }
+  private async submitDomainOrderWithRetry(
+    orderData: any,
+    url: string,
+    rootDomain: string,
+    totalLength: number,
+    maxRetries: number = 5
+  ): Promise<{ response: Response; subdomain: string; domain: string; bindDomainCap: any }> {
+    let lastError: Error | null = null;
+
+    // eslint-disable-next-line no-await-in-loop
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const subdomain = generateRandomSubdomain(totalLength);
+      const domain = `${subdomain}.${rootDomain}`;
 
-      const timestamp = Date.now();
-      const timeStr = timestamp.toString(36);
-      let suffix = timeStr.slice(-suffixLength);
+      logger.info(`Domain generation attempt ${attempt}/${maxRetries}`, {
+        subdomain,
+        domain,
+        checkoutSessionId: orderData.checkoutSessionId,
+      });
 
-      // Pad with random chars if timestamp is shorter than needed
-      while (suffix.length < suffixLength) {
-        suffix = Math.floor(Math.random() * 36).toString(36) + suffix;
-      }
+      // Generate bindDomainCap for this domain
+      const bindDomainCap = this.generateBindCap({
+        domain,
+        checkoutSessionId: orderData.checkoutSessionId,
+      });
 
-      return `${prefix}${separator}${suffix}`;
-    }
+      // Update order data with current domain info
+      const updatedOrderData = {
+        ...orderData,
+        deliveryParams: {
+          ...orderData.deliveryParams,
+          customParams: {
+            ...orderData.deliveryParams.customParams,
+            subdomain,
+            rootDomain,
+            domain,
+            bindDomainCap,
+          },
+        },
+      };
 
-    // Pure timestamp-based without prefix
-    const timestamp = Date.now();
-    const timeStr = timestamp.toString(36);
-    let result = timeStr.slice(-totalLength);
+      try {
+        const { headers, body } = VendorAuth.signRequestWithHeaders(updatedOrderData);
+
+        // eslint-disable-next-line no-await-in-loop
+        const response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body,
+        });
+
+        if (response.ok) {
+          logger.info('domain registration successful', {
+            subdomain,
+            domain,
+            attempt,
+            checkoutSessionId: orderData.checkoutSessionId,
+          });
+          return { response, subdomain, domain, bindDomainCap };
+        }
+
+        // Handle error response
+        // eslint-disable-next-line no-await-in-loop
+        const errorBody = await response.text();
+        let errorData;
+
+        try {
+          errorData = JSON.parse(errorBody);
+        } catch {
+          errorData = { message: errorBody };
+        }
+
+        if (errorData.code === DOMAIN_CONFLICT_ERROR_CODE && attempt < maxRetries) {
+          logger.warn('domain not available, retrying with new domain', {
+            subdomain,
+            domain,
+            attempt,
+            remainingAttempts: maxRetries - attempt,
+            checkoutSessionId: orderData.checkoutSessionId,
+          });
+          // eslint-disable-next-line no-continue
+          continue; // Try again with new domain
+        }
+
+        const errorMsg =
+          errorData.code === DOMAIN_CONFLICT_ERROR_CODE
+            ? `failed to find available domain after ${maxRetries} attempts`
+            : `did names API error: ${response.status} ${response.statusText} - ${errorData.message || errorBody}`;
+
+        logger.error('did names API error', {
+          url,
+          status: response.status,
+          statusText: response.statusText,
+          body: errorBody,
+          subdomain,
+          attempt,
+          isDomainConflict: errorData.code === DOMAIN_CONFLICT_ERROR_CODE,
+        });
 
-    // Pad with random chars if needed
-    while (result.length < totalLength) {
-      result = Math.floor(Math.random() * 36).toString(36) + result;
+        throw new Error(errorMsg);
+      } catch (error: any) {
+        lastError = error;
+
+        // If it's a network error and not max retries, continue
+        if (attempt < maxRetries && !error.message.includes('did names API error')) {
+          logger.warn('network error during domain registration, retrying', {
+            error: error.message,
+            attempt,
+            remainingAttempts: maxRetries - attempt,
+            checkoutSessionId: orderData.checkoutSessionId,
+          });
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        throw error;
+      }
     }
 
-    return result;
+    throw lastError || new Error('Unknown error occurred during domain registration');
   }
 
   /**
@@ -132,57 +245,33 @@ export class DidnamesAdapter implements VendorAdapter {
 
       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 totalLength = parseDomainLength(vendorConfig.metadata?.subDomainLength, 8);
 
-      const orderData = {
+      // Prepare base order data
+      const baseOrderData = {
         checkoutSessionId: params.checkoutSessionId,
         description: params.description,
         userInfo: params.userInfo,
-        deliveryParams: params.deliveryParams,
+        deliveryParams: {
+          ...params.deliveryParams,
+          customParams: {
+            ...params.deliveryParams.customParams,
+            years: 1,
+            whoisPrivacy: true,
+            checkoutSessionId: params.checkoutSessionId,
+          },
+        },
       };
 
       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}`);
-      }
+      // Use the retry wrapper to submit order with domain conflict handling
+      const { response, subdomain, domain, bindDomainCap } = await this.submitDomainOrderWithRetry(
+        baseOrderData,
+        url,
+        rootDomain,
+        totalLength
+      );
 
       const didNamesResult = await response.json();
 

package/api/src/queues/vendors/fulfillment-coordinator.ts

@@ -4,14 +4,18 @@ import { events } from '../../libs/event';
 import { getLock } from '../../libs/lock';
 import logger from '../../libs/logger';
 import createQueue from '../../libs/queue';
+import dayjs from '../../libs/dayjs';
 import { VendorFulfillmentService } from '../../libs/vendor-util/fulfillment';
 import { CheckoutSession } from '../../store/models/checkout-session';
 import { PaymentIntent } from '../../store/models/payment-intent';
 import { Price } from '../../store/models/price';
 import { Product } from '../../store/models/product';
 import { Refund } from '../../store/models/refund';
+import { Subscription } from '../../store/models/subscription';
 import { sequelize } from '../../store/sequelize';
 import { depositVaultQueue } from '../payment';
+import { addSubscriptionJob } from '../subscription';
+import { SubscriptionWillCanceledSchedule } from '../../crons/subscription-will-canceled';
 import { Invoice } from '../../store/models';
 
 export type VendorInfo = NonNullable<CheckoutSession['vendor_info']>[number];
@@ -634,6 +638,11 @@ export async function initiateFullRefund(invoiceId: string, reason: string): Pro
     await checkoutSession.update({ fulfillment_status: 'cancelled' });
     await requestReturnsFromCompletedVendors(checkoutSession, reason);
 
+    // Cancel subscription if this refund is for a subscription
+    if (checkoutSession.subscription_id) {
+      await cancelSubscriptionForRefund(checkoutSession.subscription_id, reason);
+    }
+
     // Calculate remaining amount using the same logic as subscription createProration
     const refunds = await Refund.findAll({
       where: {
@@ -707,6 +716,66 @@ export async function initiateFullRefund(invoiceId: string, reason: string): Pro
   }
 }
 
+/**
+ * Cancel subscription when full refund is initiated due to vendor fulfillment failure
+ */
+async function cancelSubscriptionForRefund(subscriptionId: string, reason: string): Promise<void> {
+  try {
+    const subscription = await Subscription.findByPk(subscriptionId);
+    if (!subscription) {
+      logger.warn('Subscription not found for cancellation', { subscriptionId });
+      return;
+    }
+
+    // Check if subscription is already canceled
+    if (subscription.status === 'canceled') {
+      logger.info('Subscription already canceled, skipping', { subscriptionId });
+      return;
+    }
+
+    const now = dayjs().unix() + 3;
+    const haveStake = !!subscription.payment_details?.arcblock?.staking?.tx_hash;
+
+    // Prepare cancellation details
+    const updates: Partial<Subscription> = {
+      status: 'canceled',
+      cancel_at: now,
+      canceled_at: now,
+      cancelation_details: {
+        comment: `Canceled due to vendor fulfillment failure: ${reason}`,
+        reason: 'vendor_fulfillment_failed',
+        feedback: 'vendor_issue',
+        return_stake: haveStake, // Return stake when canceled due to vendor failure
+        slash_stake: false,
+        slash_reason: '',
+      },
+    };
+
+    // Update subscription
+    await subscription.update(updates);
+
+    // Schedule cancellation job
+    await addSubscriptionJob(subscription, 'cancel', true, updates.cancel_at);
+
+    // Update scheduled tasks
+    await new SubscriptionWillCanceledSchedule().reScheduleSubscriptionTasks([subscription]);
+
+    logger.info('Subscription canceled due to vendor fulfillment failure', {
+      subscriptionId: subscription.id,
+      customerId: subscription.customer_id,
+      reason,
+      cancelAt: subscription.cancel_at,
+      returnStake: haveStake,
+    });
+  } catch (error: any) {
+    logger.error('Failed to cancel subscription for refund', {
+      subscriptionId,
+      reason,
+      error,
+    });
+  }
+}
+
 async function requestReturnsFromCompletedVendors(checkoutSession: CheckoutSession, reason: string): Promise<void> {
   logger.info('Starting return request process', {
     checkoutSessionId: checkoutSession.id,

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

@@ -1329,6 +1329,49 @@ router.get('/retrieve/:id', user, async (req, res) => {
   });
 });
 
+// for checkout page
+router.get('/broker-status/:id', user, async (req, res) => {
+  const { needShortUrl = false } = req.query;
+  const doc = await CheckoutSession.findByPk(req.params.id);
+
+  if (!doc) {
+    res.json({
+      checkoutSession: {},
+      paymentLink: null,
+    });
+    return;
+  }
+
+  // @ts-ignore
+  doc.line_items = await Price.expand(doc.line_items, { upsell: true });
+
+  const hasVendorConfig = doc.line_items?.some((item: any) => !!item?.price?.product?.vendor_config?.length);
+
+  if (!hasVendorConfig || doc.payment_status === 'unpaid' || doc.fulfillment_status === 'cancelled') {
+    res.json({
+      checkoutSession: {},
+      paymentLink: null,
+    });
+    return;
+  }
+
+  const paymentUrl = getUrl(`/checkout/pay/${doc.id}`);
+  const paymentLink = needShortUrl
+    ? await formatToShortUrl({
+        url: paymentUrl,
+        validUntil: dayjs().add(20, 'minutes').format('YYYY-MM-DDTHH:mm:ss+00:00'),
+        maxVisits: 5,
+      })
+    : paymentUrl;
+
+  res.json({
+    checkoutSession: {
+      ...doc.toJSON(),
+    },
+    paymentLink,
+  });
+});
+
 async function checkVendorConfig(items: TLineItemExpanded[]) {
   const lineItems = await Price.expand(items, { upsell: true });
   return lineItems?.some((item: TLineItemExpanded) => !!item?.price?.product?.vendor_config?.length);

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.21.8
+version: 1.21.10
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.21.8",
+  "version": "1.21.10",
   "scripts": {
     "dev": "blocklet dev --open",
     "lint": "tsc --noEmit && eslint src api/src --ext .mjs,.js,.jsx,.ts,.tsx",
@@ -56,9 +56,9 @@
     "@blocklet/error": "^0.2.5",
     "@blocklet/js-sdk": "^1.16.52",
     "@blocklet/logger": "^1.16.52",
-    "@blocklet/payment-broker-client": "1.21.8",
-    "@blocklet/payment-react": "1.21.8",
-    "@blocklet/payment-vendor": "1.21.8",
+    "@blocklet/payment-broker-client": "1.21.10",
+    "@blocklet/payment-react": "1.21.10",
+    "@blocklet/payment-vendor": "1.21.10",
     "@blocklet/sdk": "^1.16.52",
     "@blocklet/ui-react": "^3.1.46",
     "@blocklet/uploader": "^0.2.13",
@@ -128,7 +128,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.52",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.21.8",
+    "@blocklet/payment-types": "1.21.10",
     "@types/cookie-parser": "^1.4.9",
     "@types/cors": "^2.8.19",
     "@types/debug": "^4.1.12",
@@ -175,5 +175,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "d97f6b353583b95b2e0ec49ea66ab45426658532"
+  "gitHead": "a7288f2742e4bb2622505b79dd539616a6a59878"
 }

package/src/components/subscription/vendor-service-list.tsx

@@ -82,7 +82,7 @@ export default function VendorServiceList({
                     {vendor.name || vendor.vendor_key}
                   </Typography>
                 </Stack>
-                {isLauncher && (
+                {isLauncher && !isCanceled && (
                   <Box>
                     <Stack direction="row" spacing={0.5}>
                       <Tooltip title={t('admin.subscription.serviceHome')} placement="top">