payment-kit 1.19.18 → 1.19.20

package/api/src/routes/auto-recharge-configs.ts

@@ -0,0 +1,454 @@
+import { Router } from 'express';
+import Joi from 'joi';
+
+import { CustomError } from '@blocklet/error';
+import { Op } from 'sequelize';
+import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
+import { BN, fromTokenToUnit, fromUnitToToken } from '@ocap/util';
+import {
+  AutoRechargeConfig,
+  Customer,
+  EVMChainType,
+  PaymentCurrency,
+  PaymentMethod,
+  Price,
+  Product,
+  TPriceExpanded,
+} from '../store/models';
+import { isDelegationSufficientForPayment } from '../libs/payment';
+import { getPriceUintAmountByCurrency, validateStripePaymentAmounts } from '../libs/session';
+import { ensureStripeSetupIntentForAutoRecharge } from '../integrations/stripe/resource';
+import logger from '../libs/logger';
+
+const router = Router();
+
+const createConfigSchema = Joi.object({
+  customer_id: Joi.string().required(),
+  enabled: Joi.boolean().default(false),
+  threshold: Joi.number().default(0),
+  currency_id: Joi.string().required(),
+  recharge_currency_id: Joi.string().optional(),
+  payment_method_id: Joi.string().optional(),
+  price_id: Joi.string().optional(),
+  quantity: Joi.number().integer().min(1).default(1),
+  change_payment_method: Joi.boolean().default(false),
+  daily_limits: Joi.object({
+    max_attempts: Joi.number().integer().min(0).default(0).optional(),
+    max_amount: Joi.number().min(0).default(0).optional(),
+  }).optional(),
+});
+
+const getConfigSchema = Joi.object({
+  currency_id: Joi.string().optional(),
+});
+
+// Helper functions for validation and retrieval
+async function ensureCustomerExists(customerId: string): Promise<Customer> {
+  const customer = await Customer.findByPkOrDid(customerId);
+  if (!customer) {
+    throw new CustomError(404, 'Customer not found');
+  }
+  return customer;
+}
+
+async function ensureCurrencyWithRechargeConfig(currencyId: string): Promise<PaymentCurrency> {
+  const currency = await PaymentCurrency.scope('withRechargeConfig').findByPk(currencyId);
+  if (!currency) {
+    throw new CustomError(404, 'Payment currency not found');
+  }
+  if (!currency.recharge_config?.base_price_id) {
+    throw new CustomError(404, 'No top-up package found');
+  }
+  return currency;
+}
+
+async function ensurePaymentMethodExists(paymentMethodId: string): Promise<PaymentMethod> {
+  const paymentMethod = await PaymentMethod.findByPk(paymentMethodId);
+  if (!paymentMethod) {
+    throw new CustomError(400, `Payment method not found: ${paymentMethodId}`);
+  }
+  return paymentMethod;
+}
+
+// Apply balance check results to configuration
+async function applyBalanceCheckResults(
+  config: AutoRechargeConfig,
+  balanceResult: any,
+  paymentMethod: PaymentMethod,
+  enableIfSufficient = false
+): Promise<void> {
+  const updates: any = {};
+
+  if (balanceResult.stripeContext) {
+    updates.payment_details = {
+      stripe: {
+        setup_intent_id: balanceResult.stripeContext.id,
+        customer_id: balanceResult.stripeContext.stripe_customer_id,
+      },
+    };
+  }
+
+  const existingPayer =
+    config.payment_settings?.payment_method_options?.[
+      paymentMethod.type as keyof typeof config.payment_settings.payment_method_options
+    ]?.payer;
+
+  if (balanceResult.sufficient && balanceResult.payer && balanceResult.payer !== existingPayer) {
+    updates.payment_settings = {
+      payment_method_options: {
+        ...(config.payment_settings?.payment_method_options || {}),
+        [paymentMethod.type]: {
+          ...(config.payment_settings?.payment_method_options?.[
+            paymentMethod.type as keyof typeof config.payment_settings.payment_method_options
+          ] || {}),
+          payer: balanceResult.payer,
+        },
+      },
+      payment_method_types: [paymentMethod.type],
+    };
+
+    if (enableIfSufficient) {
+      updates.enabled = true;
+    }
+  }
+
+  if (Object.keys(updates).length > 0) {
+    await config.update(updates);
+  }
+}
+
+// Get auto-recharge configuration for a customer
+router.get('/customer/:customerId', sessionMiddleware({ accessKey: true }), async (req, res) => {
+  const { error, value } = getConfigSchema.validate(req.query, {
+    stripUnknown: true,
+  });
+  if (error) {
+    throw new CustomError(400, error.message || 'Validation error');
+  }
+
+  if (!req.user) {
+    throw new CustomError(403, 'Please login to continue');
+  }
+
+  let { customerId } = req.params;
+  if (!customerId) {
+    customerId = req.user?.did;
+  }
+
+  const { currency_id: currencyId } = value;
+  const customer = await ensureCustomerExists(customerId);
+
+  if (customer.did !== req.user?.did && !['admin', 'owner'].includes(req.user?.role)) {
+    throw new CustomError(403, 'You are not allowed to access this resource');
+  }
+
+  const where: any = {
+    customer_id: customer.id, // Use customer.id instead of customerId from params
+  };
+
+  if (currencyId) {
+    where.currency_id = currencyId;
+  }
+
+  const currency = await ensureCurrencyWithRechargeConfig(currencyId);
+
+  const config = (await AutoRechargeConfig.findOne({
+    where,
+    include: [
+      {
+        model: PaymentCurrency,
+        as: 'rechargeCurrency',
+        required: false,
+        attributes: ['id', 'name', 'symbol', 'type', 'decimal', 'logo'],
+      },
+      {
+        model: PaymentMethod,
+        as: 'paymentMethod',
+        attributes: ['id', 'type', 'name', 'active'],
+      },
+    ],
+  })) as AutoRechargeConfig & { rechargeCurrency: PaymentCurrency; paymentMethod: PaymentMethod };
+  const price = await Price.findByPk(currency.recharge_config?.base_price_id, {
+    include: [{ model: Product, as: 'product' }],
+  });
+  if (!price) {
+    throw new CustomError(404, 'Base price not found');
+  }
+  if (!config) {
+    const newConfig = await AutoRechargeConfig.create({
+      customer_id: customer.id, // Use customer.id instead of customerId from params
+      currency_id: currencyId,
+      livemode: currency.livemode,
+      enabled: false,
+      threshold: currency.minimum_payment_amount,
+      price_id: price.id,
+      quantity: 1,
+      recharge_currency_id: price.currency_id,
+    });
+    return res.json({
+      ...newConfig.toJSON(),
+      currency,
+      price,
+      threshold: fromUnitToToken(currency.minimum_payment_amount, currency.decimal),
+      customer,
+    });
+  }
+
+  if (config.price_id !== price.id) {
+    await config.update({
+      price_id: price.id,
+    });
+  }
+  return res.json({
+    ...config.toJSON(),
+    daily_limits: {
+      max_attempts: config.daily_limits?.max_attempts || 0,
+      max_amount: fromUnitToToken(config.daily_limits?.max_amount || '0', config.rechargeCurrency?.decimal || 2),
+    },
+    currency,
+    price,
+    threshold: fromUnitToToken(config.threshold || 0, currency.decimal),
+    customer,
+  });
+});
+
+// Retrieve specific auto-recharge configuration by ID
+router.get('/retrieve/:id', sessionMiddleware({ accessKey: true }), async (req, res) => {
+  const config = await AutoRechargeConfig.findByPk(req.params.id);
+  if (!config) {
+    throw new CustomError(404, 'Auto recharge config not found');
+  }
+  const paymentMethod = await PaymentMethod.findByPk(config.payment_method_id);
+  if (!paymentMethod) {
+    throw new CustomError(404, 'Payment method not found');
+  }
+  return res.json({
+    ...config.toJSON(),
+    paymentMethod,
+  });
+});
+
+async function checkSufficientBalance({
+  price,
+  quantity = 1,
+  rechargeCurrency,
+  userDid,
+  customer,
+  autoRechargeConfig,
+  forceReauthorize = false,
+}: {
+  price: Price;
+  quantity: number;
+  rechargeCurrency: PaymentCurrency;
+  userDid: string;
+  customer: Customer;
+  autoRechargeConfig: AutoRechargeConfig;
+  forceReauthorize?: boolean;
+}) {
+  const priceAmount = await getPriceUintAmountByCurrency(price, rechargeCurrency.id);
+  const amount = new BN(priceAmount).mul(new BN(quantity));
+  const paymentMethod = await PaymentMethod.findByPk(rechargeCurrency.payment_method_id);
+
+  if (!paymentMethod) {
+    throw new CustomError(400, `Payment method not found: ${rechargeCurrency.payment_method_id}`);
+  }
+
+  const payer =
+    autoRechargeConfig.payment_settings?.payment_method_options?.[
+      paymentMethod?.type as 'arcblock' | EVMChainType | 'stripe'
+    ]?.payer || userDid;
+
+  if (paymentMethod.type === 'stripe') {
+    if (forceReauthorize || !autoRechargeConfig.payment_settings?.payment_method_options?.stripe?.payer) {
+      const setupIntent = await ensureStripeSetupIntentForAutoRecharge(
+        customer,
+        paymentMethod,
+        autoRechargeConfig,
+        forceReauthorize
+      );
+
+      return {
+        sufficient: false,
+        stripeContext: {
+          type: 'setup_intent',
+          id: setupIntent.id,
+          client_secret: setupIntent.client_secret,
+          intent_type: 'setup_intent',
+          status: setupIntent.status,
+          stripe_customer_id: setupIntent.customer as string,
+        },
+      };
+    }
+    return {
+      sufficient: true,
+      payer,
+    };
+  }
+  const delegation = await isDelegationSufficientForPayment({
+    paymentMethod,
+    paymentCurrency: rechargeCurrency,
+    userDid: payer,
+    amount: amount.toString(),
+  });
+
+  return {
+    sufficient: delegation.sufficient,
+    delegation,
+    payer,
+  };
+}
+
+// Submit auto-recharge configuration
+router.post('/submit', async (req, res) => {
+  const { error, value } = createConfigSchema.validate(req.body, {
+    stripUnknown: true,
+  });
+  if (error) {
+    throw new CustomError(400, error.message || 'Validation error');
+  }
+
+  const { customer_id: customerId, ...configData } = value;
+
+  // Validate all required entities
+  const customer = await ensureCustomerExists(customerId);
+  const currency = await PaymentCurrency.scope('withRechargeConfig').findByPk(value.currency_id);
+  if (!currency) {
+    throw new CustomError(400, `Currency not found: ${value.currency_id}`);
+  }
+
+  if (currency.recharge_config?.base_price_id && currency.recharge_config?.base_price_id !== value.price_id) {
+    throw new CustomError(400, 'Price is not the base price');
+  }
+
+  const rechargeCurrency = await PaymentCurrency.findByPk(value.recharge_currency_id);
+  if (!rechargeCurrency) {
+    throw new CustomError(400, `Recharge currency not found: ${value.recharge_currency_id}`);
+  }
+
+  const paymentMethod = await ensurePaymentMethodExists(rechargeCurrency.payment_method_id);
+
+  const price = (await Price.findOne({
+    where: {
+      [Op.or]: [{ id: value.price_id }, { lookup_key: value.price_id }],
+      active: true,
+    },
+    include: [{ model: Product, as: 'product' }],
+  })) as TPriceExpanded | null;
+
+  if (!price) {
+    throw new CustomError(400, `Active price not found: ${value.price_id}`);
+  }
+  let { threshold, daily_limits: dailyLimits } = configData;
+  if (threshold) {
+    threshold = fromTokenToUnit(parseFloat(threshold).toFixed(currency.decimal), currency.decimal).toString();
+  }
+  if (dailyLimits) {
+    dailyLimits = {
+      max_attempts: dailyLimits.max_attempts || 0,
+      max_amount: fromTokenToUnit(
+        parseFloat(dailyLimits.max_amount || '0').toFixed(rechargeCurrency.decimal),
+        rechargeCurrency.decimal
+      ).toString(),
+    };
+  }
+  if (paymentMethod.type === 'stripe' && configData.enabled) {
+    const priceAmount = getPriceUintAmountByCurrency(price, rechargeCurrency.id);
+    if (!priceAmount) {
+      throw new CustomError(400, 'Price amount is not valid');
+    }
+    const result = validateStripePaymentAmounts(
+      new BN(priceAmount).mul(new BN(Number(configData.quantity || '0'))).toString(),
+      rechargeCurrency
+    );
+    if (!result) {
+      throw new CustomError(400, 'Auto Top-up amount must be greater or equal to 0.5 USD');
+    }
+  }
+
+  const existingConfig = await AutoRechargeConfig.findOne({
+    where: {
+      customer_id: customer.id,
+      currency_id: value.currency_id,
+    },
+  });
+
+  if (existingConfig) {
+    if (!configData.enabled) {
+      await existingConfig.update({
+        enabled: false,
+      });
+      return res.json({
+        ...existingConfig.toJSON(),
+        paymentMethod,
+        customer,
+      });
+    }
+    // if exist, update it
+    await existingConfig.update({
+      ...configData,
+      currency_id: value.currency_id,
+      recharge_currency_id: value.recharge_currency_id,
+      price_id: price.id,
+      payment_method_id: rechargeCurrency.payment_method_id,
+      threshold: threshold ?? existingConfig.threshold,
+      daily_limits: dailyLimits,
+    });
+    const balanceResult = await checkSufficientBalance({
+      price: price as unknown as Price,
+      quantity: value.quantity,
+      rechargeCurrency,
+      userDid: customer.did,
+      customer,
+      autoRechargeConfig: existingConfig,
+      forceReauthorize: value.change_payment_method,
+    });
+    // Update payment details and settings based on balance check result
+    await applyBalanceCheckResults(existingConfig, balanceResult, paymentMethod);
+    return res.json({
+      ...existingConfig.toJSON(),
+      balanceResult,
+      paymentMethod,
+      customer,
+    });
+  }
+
+  const config = await AutoRechargeConfig.create({
+    customer_id: customer.id, // Use customer.id instead of customerId from params
+    currency_id: value.currency_id,
+    recharge_currency_id: value.recharge_currency_id,
+    price_id: price.id,
+    livemode: currency.livemode,
+    enabled: configData.enabled ?? false,
+    threshold: threshold || '0',
+    quantity: Number(configData.quantity || '1'),
+    payment_method_id: rechargeCurrency.payment_method_id,
+    daily_limits: dailyLimits,
+  });
+
+  logger.info('Auto recharge config created', {
+    configId: config.id,
+    customerId: customer.id,
+    currencyId: value.currency_id,
+  });
+
+  const balanceResult = await checkSufficientBalance({
+    price: price as unknown as Price,
+    quantity: value.quantity,
+    rechargeCurrency,
+    userDid: customer.did,
+    customer,
+    autoRechargeConfig: config as AutoRechargeConfig,
+    forceReauthorize: value.change_payment_method,
+  });
+
+  // Update payment details and settings based on balance check result
+  await applyBalanceCheckResults(config, balanceResult, paymentMethod, true);
+  return res.json({
+    ...config.toJSON(),
+    balanceResult,
+    paymentMethod,
+    customer,
+  });
+});
+
+export default router;

package/api/src/routes/connect/auto-recharge-auth.ts

@@ -0,0 +1,182 @@
+import {
+  broadcastAutoRechargeEvmTransaction,
+  executeEvmTransaction,
+  waitForEvmTxConfirm,
+} from '../../integrations/ethereum/tx';
+import type { CallbackArgs } from '../../libs/auth';
+import logger from '../../libs/logger';
+import { getTxMetadata } from '../../libs/util';
+import {
+  ensureAutoRechargeAuthorization,
+  executeOcapTransactions,
+  getAuthPrincipalClaim,
+  getDelegationTxClaim,
+} from './shared';
+import { EVM_CHAIN_TYPES } from '../../libs/constants';
+import { Price } from '../../store/models';
+
+export default {
+  action: 'auto-recharge-auth',
+  authPrincipal: false,
+  persistentDynamicClaims: true,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureAutoRechargeAuthorization(extraParams.autoRechargeConfigId);
+      return getAuthPrincipalClaim(paymentMethod, 'auto-recharge-auth');
+    },
+  },
+  onConnect: async (args: CallbackArgs) => {
+    const { userDid, userPk, extraParams } = args;
+    const { autoRechargeConfigId } = extraParams;
+    const { autoRechargeConfig, paymentMethod, paymentCurrency } =
+      await ensureAutoRechargeAuthorization(autoRechargeConfigId);
+    const claimsList: any[] = [];
+    const expandedItems = await Price.expand(
+      [{ price_id: autoRechargeConfig.price_id, quantity: autoRechargeConfig.quantity }],
+      {
+        product: true,
+      }
+    );
+    if (paymentMethod.type === 'arcblock') {
+      claimsList.push({
+        signature: await getDelegationTxClaim({
+          mode: 'auto-recharge-auth',
+          userDid,
+          userPk,
+          nonce: autoRechargeConfig.id,
+          data: getTxMetadata({
+            autoRechargeConfigId,
+          }),
+          paymentCurrency,
+          paymentMethod,
+          trialing: false,
+          billingThreshold: 0,
+          items: expandedItems,
+          requiredStake: false,
+        }),
+      });
+
+      return claimsList;
+    }
+
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
+      if (!paymentCurrency.contract) {
+        throw new Error(`Payment currency ${paymentMethod.type}:${paymentCurrency.id} does not support subscription`);
+      }
+
+      claimsList.push({
+        signature: await getDelegationTxClaim({
+          mode: 'auto-recharge-auth',
+          userDid,
+          userPk,
+          nonce: autoRechargeConfig.id,
+          data: getTxMetadata({
+            autoRechargeConfigId,
+          }),
+          paymentCurrency,
+          paymentMethod,
+          trialing: false,
+          billingThreshold: 0,
+          items: expandedItems,
+          requiredStake: false,
+        }),
+      });
+
+      return claimsList;
+    }
+
+    throw new Error(`subscription: Payment method ${paymentMethod.type} not supported`);
+  },
+  onAuth: async (args: CallbackArgs) => {
+    const { request, userDid, userPk, claims, extraParams, updateSession, step } = args;
+    const { autoRechargeConfigId } = extraParams;
+    const { autoRechargeConfig, paymentMethod, paymentCurrency } =
+      await ensureAutoRechargeAuthorization(autoRechargeConfigId);
+    const result = request?.context?.store?.result || [];
+    result.push({
+      step,
+      claim: claims?.[0],
+      stepRequest: {
+        headers: request?.headers,
+      },
+    });
+    try {
+      await updateSession({
+        result: [],
+      });
+    } catch (error) {
+      logger.error('updateSession', {
+        error,
+      });
+    }
+    const claimsList = result.map((x: any) => x.claim);
+
+    const paymentSettings = {
+      payment_method_types: [paymentMethod.type],
+      payment_method_options: {
+        ...(autoRechargeConfig.payment_settings?.payment_method_options || {}),
+        [paymentMethod.type]: { payer: userDid },
+      },
+    };
+    const prepareTxExecution = async () => {
+      await autoRechargeConfig.update({ payment_settings: paymentSettings });
+    };
+
+    const afterTxExecution = async (paymentDetails: Record<string, any>) => {
+      await autoRechargeConfig.update({
+        payment_details: { ...autoRechargeConfig.payment_details, [paymentMethod.type]: paymentDetails },
+        enabled: true,
+      });
+      logger.info('enable auto recharge success', {
+        autoRechargeConfigId,
+      });
+    };
+
+    if (paymentMethod.type === 'arcblock') {
+      await prepareTxExecution();
+
+      const requestArray = result
+        .map((item: { stepRequest?: Request }) => item.stepRequest)
+        .filter(Boolean) as Request[];
+
+      const requestSource = requestArray.length > 0 ? requestArray : request;
+
+      const { stakingAmount, ...paymentDetails } = await executeOcapTransactions(
+        userDid,
+        userPk,
+        claimsList,
+        paymentMethod,
+        requestSource,
+        '',
+        paymentCurrency?.contract,
+        autoRechargeConfig.id
+      );
+
+      await afterTxExecution(paymentDetails);
+
+      return { hash: paymentDetails.tx_hash };
+    }
+
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
+      await prepareTxExecution();
+
+      broadcastAutoRechargeEvmTransaction(autoRechargeConfigId, 'pending', claimsList);
+
+      const paymentDetails = await executeEvmTransaction('approve', userDid, claimsList, paymentMethod);
+      waitForEvmTxConfirm(
+        paymentMethod.getEvmClient(),
+        Number(paymentDetails.block_height),
+        paymentMethod.confirmation.block
+      )
+        .then(async () => {
+          await afterTxExecution(paymentDetails);
+          broadcastAutoRechargeEvmTransaction(autoRechargeConfigId, 'confirmed', claimsList);
+        })
+        .catch(console.error);
+
+      return { hash: paymentDetails.tx_hash };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};