payment-kit 1.19.18 → 1.19.19

package/api/src/routes/connect/recharge-account.ts

@@ -1,35 +1,48 @@
 import type { Transaction } from '@ocap/client';
 import { fromAddress } from '@ocap/wallet';
-import { fromTokenToUnit } from '@ocap/util';
+import { fromTokenToUnit, toBase58 } from '@ocap/util';
+import { encodeTransferItx } from '../../integrations/ethereum/token';
+import { executeEvmTransaction, waitForEvmTxConfirm } from '../../integrations/ethereum/tx';
 import type { CallbackArgs } from '../../libs/auth';
 import { getGasPayerExtra } from '../../libs/payment';
 import { getTxMetadata } from '../../libs/util';
 import { ensureAccountRecharge, getAuthPrincipalClaim } from './shared';
 import logger from '../../libs/logger';
 import { ensureRechargeInvoice, retryUncollectibleInvoices } from '../../libs/invoice';
+import { EVMChainType } from '../../store/models';
+import { EVM_CHAIN_TYPES } from '../../libs/constants';
 
 export default {
   action: 'recharge-account',
   authPrincipal: false,
   claims: {
     authPrincipal: async ({ extraParams }: CallbackArgs) => {
-      const { paymentMethod } = await ensureAccountRecharge(extraParams.customerDid, extraParams.currencyId);
+      const { paymentMethod } = await ensureAccountRecharge(
+        extraParams.customerDid,
+        extraParams.currencyId,
+        extraParams.rechargeAddress
+      );
       return getAuthPrincipalClaim(paymentMethod, 'recharge-account');
     },
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
-    const { customerDid, currencyId } = extraParams;
+    const { customerDid, currencyId, rechargeAddress } = extraParams;
     let { amount } = extraParams;
-    const { paymentMethod, paymentCurrency, customer } = await ensureAccountRecharge(customerDid, currencyId);
+    const { paymentMethod, paymentCurrency, customer, receiverAddress } = await ensureAccountRecharge(
+      customerDid,
+      currencyId,
+      rechargeAddress
+    );
     amount = fromTokenToUnit(amount, paymentCurrency.decimal).toString();
     if (paymentMethod.type === 'arcblock') {
       const tokens = [{ address: paymentCurrency.contract as string, value: amount }];
       // @ts-ignore
       const itx: TransferV3Tx = {
-        outputs: [{ owner: customerDid, tokens, assets: [] }],
+        outputs: [{ owner: receiverAddress, tokens, assets: [] }],
         data: getTxMetadata({
           rechargeCustomerId: customer.id,
           customerDid,
+          receiverAddress,
           currencyId: paymentCurrency.id,
           amount,
           action: 'recharge-account',
@@ -39,7 +52,7 @@ export default {
       const claims: { [key: string]: object } = {
         prepareTx: {
           type: 'TransferV3Tx',
-          description: `Recharge account for ${customerDid}`,
+          description: `Recharge account for ${receiverAddress}`,
           partialTx: { from: userDid, pk: userPk, itx },
           requirement: { tokens },
           chainInfo: {
@@ -52,11 +65,32 @@ export default {
       return claims;
     }
 
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
+      return {
+        signature: {
+          type: 'eth:transaction',
+          data: toBase58(
+            Buffer.from(
+              JSON.stringify({
+                network: paymentMethod.settings[paymentMethod.type as EVMChainType]?.chain_id,
+                tx: encodeTransferItx(receiverAddress, amount, paymentCurrency.contract as string),
+              }),
+              'utf-8'
+            )
+          ),
+        },
+      };
+    }
+
     throw new Error(`Payment method ${paymentMethod.type} not supported`);
   },
   onAuth: async ({ request, userDid, claims, extraParams }: CallbackArgs) => {
-    const { customerDid, currencyId } = extraParams;
-    const { paymentMethod, paymentCurrency, customer } = await ensureAccountRecharge(customerDid, currencyId);
+    const { customerDid, currencyId, rechargeAddress } = extraParams;
+    const { paymentMethod, paymentCurrency, customer, receiverAddress } = await ensureAccountRecharge(
+      customerDid,
+      currencyId,
+      rechargeAddress
+    );
     let { amount } = extraParams;
     amount = fromTokenToUnit(amount, paymentCurrency.decimal).toString();
 
@@ -69,7 +103,7 @@ export default {
           metadata: {
             payment_details: {
               [paymentMethod.type]: paymentDetails,
-              receiverAddress: customerDid,
+              receiverAddress,
             },
           },
           livemode: paymentCurrency?.livemode,
@@ -126,7 +160,35 @@ export default {
         return { hash: txHash };
       } catch (err) {
         console.error(err);
-        logger.error('Failed to finalize recharge on arcblock', { receiverAddress: customerDid, error: err });
+        logger.error('Failed to finalize recharge on arcblock', {
+          receiverAddress,
+          customerId: customer.id,
+          error: err,
+        });
+        throw err;
+      }
+    }
+
+    if (EVM_CHAIN_TYPES.includes(paymentMethod.type)) {
+      try {
+        const paymentDetails = await executeEvmTransaction('transfer', userDid, claims, paymentMethod);
+        waitForEvmTxConfirm(
+          paymentMethod.getEvmClient(),
+          Number(paymentDetails.block_height),
+          paymentMethod.confirmation.block
+        )
+          .then(async () => {
+            await afterTxExecution(paymentDetails);
+          })
+          .catch(console.error);
+
+        return { hash: paymentDetails.tx_hash };
+      } catch (err) {
+        console.error(err);
+        logger.error(`Failed to finalize recharge on ${paymentMethod.type}`, {
+          receiverAddress,
+          error: err,
+        });
         throw err;
       }
     }

package/api/src/routes/connect/setup.ts

@@ -26,15 +26,17 @@ export default {
   persistentDynamicClaims: true,
   claims: {
     authPrincipal: async ({ extraParams }: CallbackArgs) => {
-      const { paymentMethod } = await ensureSetupIntent(extraParams.checkoutSessionId);
+      const { paymentMethod } = await ensureSetupIntent(extraParams.checkoutSessionId, true);
       return getAuthPrincipalClaim(paymentMethod, 'subscribe');
     },
   },
   onConnect: async (args: CallbackArgs) => {
     const { userDid, userPk, extraParams } = args;
     const { checkoutSessionId } = extraParams;
-    const { paymentMethod, paymentCurrency, checkoutSession, subscription } =
-      await ensureSetupIntent(checkoutSessionId);
+    const { paymentMethod, paymentCurrency, checkoutSession, subscription } = await ensureSetupIntent(
+      checkoutSessionId,
+      true
+    );
     if (!subscription) {
       throw new Error('Subscription for checkoutSession not found');
     }

package/api/src/routes/connect/shared.ts

@@ -30,7 +30,7 @@ import {
 import { getCustomerStakeAddress, OCAP_PAYMENT_TX_TYPE } from '../../libs/util';
 
 import { invoiceQueue } from '../../queues/invoice';
-import { type TLineItemExpanded } from '../../store/models';
+import { AutoRechargeConfig, type TLineItemExpanded } from '../../store/models';
 import { CheckoutSession } from '../../store/models/checkout-session';
 import { Customer } from '../../store/models/customer';
 import { Invoice, TInvoice } from '../../store/models/invoice';
@@ -212,7 +212,7 @@ export async function ensurePaymentIntent(
   };
 }
 
-export async function ensureSetupIntent(checkoutSessionId: string) {
+export async function ensureSetupIntent(checkoutSessionId: string, skipInvoice?: boolean) {
   const checkoutSession = await ensureCheckoutSession(checkoutSessionId);
 
   if (!checkoutSession.setup_intent_id) {
@@ -264,7 +264,7 @@ export async function ensureSetupIntent(checkoutSessionId: string) {
   checkoutSession.line_items = await Price.expand(checkoutSession.line_items);
 
   let invoice;
-  if (subscription) {
+  if (subscription && !skipInvoice) {
     if (checkoutSession.invoice_id) {
       invoice = await Invoice.findByPk(checkoutSession.invoice_id);
     } else {
@@ -610,7 +610,7 @@ export async function ensureSubscriptionRecharge(subscriptionId: string) {
   };
 }
 
-export async function ensureAccountRecharge(customerId: string, currencyId: string) {
+export async function ensureAccountRecharge(customerId: string, currencyId: string, rechargeAddress?: string) {
   const customer = await Customer.findByPkOrDid(customerId);
   if (!customer) {
     throw new Error(`Customer ${customerId} not found`);
@@ -623,10 +623,14 @@ export async function ensureAccountRecharge(customerId: string, currencyId: stri
   if (!paymentMethod) {
     throw new Error(`Payment method ${paymentCurrency.payment_method_id} not found`);
   }
+
+  const receiverAddress = rechargeAddress || customer.did;
+  
   return {
     paymentCurrency: paymentCurrency as PaymentCurrency,
     paymentMethod: paymentMethod as PaymentMethod,
     customer,
+    receiverAddress,
   };
 }
 export function getAuthPrincipalClaim(method: PaymentMethod, action: string) {
@@ -685,6 +689,7 @@ export async function getDelegationTxClaim({
   trialing: boolean;
   billingThreshold?: number;
   requiredStake?: boolean;
+  requiredAmount?: string;
 }) {
   const amount = getFastCheckoutAmount(items, mode, paymentCurrency.id);
   const address = toDelegateAddress(userDid, wallet.address);
@@ -1416,6 +1421,42 @@ export async function updateStripeSubscriptionAfterChangePayment(setupIntent: Se
   }
 }
 
+
+export async function ensureAutoRechargeAuthorization(
+  autoRechargeConfigId: string
+): Promise<{ autoRechargeConfig: AutoRechargeConfig; paymentMethod: PaymentMethod; paymentCurrency: PaymentCurrency }> {
+  const autoRechargeConfig = await AutoRechargeConfig.findByPk(autoRechargeConfigId);
+  if (!autoRechargeConfig) {
+    throw new Error(`Auto recharge config ${autoRechargeConfigId} not found`);
+  }
+
+  const price = await Price.findByPk(autoRechargeConfig.price_id);
+  if (!price) {
+    throw new Error(`Price ${autoRechargeConfig.price_id} not found`);
+  }
+  const paymentCurrency = await PaymentCurrency.findByPk(autoRechargeConfig.recharge_currency_id);
+  if (!paymentCurrency) {
+    throw new Error(`Payment currency ${autoRechargeConfig.recharge_currency_id} not found`);
+  }
+
+  if (paymentCurrency.payment_method_id !== autoRechargeConfig.payment_method_id) {
+    await autoRechargeConfig.update({
+      payment_method_id: paymentCurrency.payment_method_id,
+    });
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+  if (!paymentMethod) {
+    throw new Error(`Payment method ${paymentCurrency.payment_method_id} not found`);
+  }
+
+  return {
+    autoRechargeConfig,
+    paymentMethod,
+    paymentCurrency,
+  };
+}
+
 export async function returnStakeForCanceledSubscription(subscriptionId: string) {
   if (!subscriptionId) {
     return;

package/api/src/routes/customers.ts

@@ -345,9 +345,14 @@ router.get('/payer-token', sessionMiddleware({ accessKey: true }), async (req, r
     return res.status(400).json({ error: 'Currency ID is required' });
   }
   try {
-    const customer = await Customer.findByPkOrDid(req.user.did as string);
-    if (!customer) {
-      return res.status(404).json({ error: 'Customer not found' });
+    let paymentAddress = req.query.payerAddress as string;
+    let customer: Customer | null = null;
+    if (!paymentAddress) {
+      customer = await Customer.findByPkOrDid(req.user.did as string);
+      if (!customer) {
+        return res.status(404).json({ error: 'Customer not found' });
+      }
+      paymentAddress = customer.did;
     }
 
     const paymentCurrency = await PaymentCurrency.findByPk(req.query.currencyId as string);
@@ -360,13 +365,12 @@ router.get('/payer-token', sessionMiddleware({ accessKey: true }), async (req, r
       return res.status(404).json({ error: 'Payment method not found' });
     }
 
-    if (paymentMethod.type !== 'arcblock') {
+    if (!['arcblock', 'ethereum', 'base'].includes(paymentMethod.type)) {
       return res.status(400).json({ error: `Payment method not supported: ${paymentMethod.type}` });
     }
 
-    const paymentAddress = customer.did;
     if (!paymentAddress) {
-      return res.status(400).json({ error: `Payment address not found for customer: ${customer.id}` });
+      return res.status(400).json({ error: `Payment address not found for customer: ${customer?.id}` });
     }
 
     const token = await getTokenByAddress(paymentAddress, paymentMethod, paymentCurrency);

package/api/src/routes/index.ts

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 
 import { PaymentCurrency } from '../store/models/payment-currency';
+import autoRechargeConfigs from './auto-recharge-configs';
 import checkoutSessions from './checkout-sessions';
 import creditGrants from './credit-grants';
 import creditTransactions from './credit-transactions';
@@ -51,6 +52,7 @@ router.use(async (req, _, next) => {
   next();
 });
 
+router.use('/auto-recharge-configs', autoRechargeConfigs);
 router.use('/checkout-sessions', checkoutSessions);
 router.use('/credit-grants', creditGrants);
 router.use('/credit-transactions', creditTransactions);

package/api/src/routes/invoices.ts

@@ -379,10 +379,12 @@ const rechargeSchema = createListParamSchema<{
   status?: string;
   customer_id?: string;
   currency_id?: string;
+  recharge_address?: string;
 }>({
   status: Joi.string().empty(''),
   customer_id: Joi.string().empty(''),
   currency_id: Joi.string().empty(''),
+  recharge_address: Joi.string().empty(''),
 });
 
 router.get('/recharge', authMine, async (req, res) => {
@@ -392,12 +394,19 @@ router.get('/recharge', authMine, async (req, res) => {
   });
   const where = getWhereFromKvQuery(query.q);
   if (query.customer_id) {
-    where.customer_id = query.customer_id;
+    const customer = await Customer.findByPkOrDid(query.customer_id);
+    if (!customer) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+    where.customer_id = customer.id;
   }
   if (query.currency_id) {
     where.currency_id = query.currency_id;
   }
 
+  if (query.recharge_address) {
+    where['metadata.payment_details.receiverAddress'] = query.recharge_address;
+  }
   try {
     const { rows: invoices, count } = await Invoice.findAndCountAll({
       where: {

package/api/src/routes/meters.ts

@@ -121,7 +121,7 @@ router.get('/:id', auth, async (req, res) => {
       where: {
         [Op.or]: [{ id: req.params.id }, { event_name: req.params.id }],
       },
-      include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
+      include: [{ model: PaymentCurrency.scope('withRechargeConfig'), as: 'paymentCurrency' }],
     });
 
     if (!meter) {

package/api/src/routes/payment-currencies.ts

@@ -4,20 +4,25 @@ import { InferAttributes, Op, WhereOptions } from 'sequelize';
 
 import Joi from 'joi';
 import pick from 'lodash/pick';
+import { getUrl } from '@blocklet/sdk';
+import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
 import { fetchErc20Meta } from '../integrations/ethereum/token';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
 import { PaymentCurrency, TPaymentCurrency } from '../store/models/payment-currency';
 import { PaymentMethod } from '../store/models/payment-method';
+import { Price, Product } from '../store/models';
 import { EVM_CHAIN_TYPES } from '../libs/constants';
 import { ethWallet, getVaultAddress, wallet } from '../libs/auth';
 import { resolveAddressChainTypes } from '../libs/util';
 import { depositVaultQueue } from '../queues/payment';
 import { checkDepositVaultAmount } from '../libs/payment';
 import { getTokenSummaryByDid } from '../integrations/arcblock/stake';
+import { createPaymentLink } from './payment-links';
 
 const router = Router();
 
+const user = sessionMiddleware({ accessKey: true });
 const auth = authenticate<PaymentCurrency>({ component: true, roles: ['owner', 'admin'] });
 const authOwner = authenticate<PaymentCurrency>({ component: true, roles: ['owner'] });
 const paymentCurrencyCreateSchema = Joi.object({
@@ -370,4 +375,128 @@ router.delete('/:id', auth, async (req, res) => {
   }
 });
 
+router.get('/:id/recharge-config', user, async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    const currency = await PaymentCurrency.scope('withRechargeConfig').findByPk(id);
+
+    if (!currency) {
+      return res.status(404).json({ error: 'Credit currency not found' });
+    }
+
+    if (!currency.recharge_config) {
+      return res.json({
+        currency_id: id,
+        recharge_config: null,
+        message: 'No recharge config available for this currency',
+      });
+    }
+
+    let basePrice: (Price & { product: Product }) | null = null;
+    if (currency.recharge_config.base_price_id) {
+      basePrice = (await Price.findByPk(currency.recharge_config.base_price_id, {
+        include: [{ model: Product, as: 'product' }],
+      })) as Price & { product: Product };
+    }
+
+    const rechargeConfig = currency.recharge_config;
+    let paymentUrl = rechargeConfig.checkout_url;
+    if (!paymentUrl && rechargeConfig.payment_link_id) {
+      paymentUrl = getUrl(`/checkout/pay/${rechargeConfig.payment_link_id}`);
+    }
+    if (!paymentUrl && rechargeConfig.base_price_id) {
+      const paymentLink = await createPaymentLink({
+        livemode: currency.livemode,
+        currency_id: basePrice?.currency_id,
+        name: basePrice?.product?.name || `${currency.name} Recharge`,
+        submit_type: 'pay',
+        line_items: [
+          {
+            price_id: rechargeConfig.base_price_id,
+            quantity: 1,
+            adjustable_quantity: {
+              enabled: true,
+              minimum: 1,
+              maximum: 100000000,
+            },
+          },
+        ],
+      });
+      await currency.update({ recharge_config: { ...rechargeConfig, payment_link_id: paymentLink.id } });
+      paymentUrl = getUrl(`/checkout/pay/${paymentLink.id}`);
+    }
+
+    return res.json({
+      currency_id: id,
+      currency_info: pick(currency, ['id', 'name', 'symbol', 'decimal', 'type']),
+      recharge_config: {
+        ...currency.recharge_config,
+        basePrice,
+        payment_url: paymentUrl,
+      },
+    });
+  } catch (error: any) {
+    logger.error('Failed to get currency recharge config', {
+      currencyId: req.params.id,
+      error: error.message,
+    });
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+const rechargeConfigSchema = Joi.object({
+  base_price_id: Joi.string().required(),
+  payment_link_id: Joi.string().optional(),
+  checkout_url: Joi.string().optional(),
+  settings: Joi.object({
+    min_recharge_amount: Joi.number().min(0).optional(),
+    max_recharge_amount: Joi.number().min(0).optional(),
+  }).optional(),
+}).unknown(true);
+
+router.put('/:id/recharge-config', auth, async (req, res) => {
+  const { id } = req.params;
+  const { error, value: rechargeConfig } = rechargeConfigSchema.validate(
+    pick(req.body, ['base_price_id', 'payment_link_id', 'checkout_url', 'settings'])
+  );
+  if (error) {
+    return res.status(400).json({ error: error.message });
+  }
+
+  const currency = await PaymentCurrency.findByPk(id);
+
+  if (!currency) {
+    return res.status(404).json({ error: 'Credit currency not found' });
+  }
+
+  if (rechargeConfig.base_price_id) {
+    const basePrice = (await Price.findOne({
+      where: {
+        id: rechargeConfig.base_price_id,
+        active: true,
+      },
+      include: [{ model: Product, as: 'product' }],
+    })) as Price & { product: Product };
+
+    if (!basePrice) {
+      return res.status(404).json({ error: 'Base price not found or inactive' });
+    }
+  }
+
+  await currency.update({ recharge_config: rechargeConfig });
+
+  logger.info('Currency recharge config updated', {
+    currencyId: id,
+    basePriceId: rechargeConfig.base_price_id,
+    tiersCount: rechargeConfig.price_tiers?.length || 0,
+  });
+
+  return res.json({
+    currency_id: id,
+    recharge_config: rechargeConfig,
+    message: 'Recharge config updated successfully',
+  });
+});
+
 export default router;

package/api/src/store/migrate.ts

@@ -46,4 +46,24 @@ export async function safeApplyColumnChanges(context: QueryInterface, changes: C
   }
 }
 
+const indexExists = async (table: string, indexName: string, queryInterface: QueryInterface) => {
+  const indexes = await queryInterface.showIndex(table);
+  return indexes && Array.isArray(indexes) && indexes.some((index: { name: string }) => index.name === indexName);
+};
+
+export const createIndexIfNotExists = async (
+  queryInterface: QueryInterface,
+  table: string,
+  columns: string[],
+  indexName: string,
+  extra?: any
+) => {
+  if (await indexExists(table, indexName, queryInterface)) {
+    /* eslint-disable no-console */
+    console.log(`Index ${indexName} already exists on ${table}, skipping...`);
+    return;
+  }
+  await queryInterface.addIndex(table, columns, { name: indexName, ...(extra || {}) });
+};
+
 export type Migration = typeof umzug._types.migration;

package/api/src/store/migrations/20250821-auto-recharge-config.ts

@@ -0,0 +1,38 @@
+import { DataTypes } from 'sequelize';
+import { AutoRechargeConfig } from '../models/auto-recharge-config';
+import { createIndexIfNotExists, Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await context.createTable('auto_recharge_configs', AutoRechargeConfig.GENESIS_ATTRIBUTES);
+
+  await createIndexIfNotExists(
+    context,
+    'auto_recharge_configs',
+    ['customer_id'],
+    'idx_auto_recharge_configs_customer_id'
+  );
+
+  await createIndexIfNotExists(
+    context,
+    'auto_recharge_configs',
+    ['currency_id'],
+    'idx_auto_recharge_configs_currency_id'
+  );
+
+  await safeApplyColumnChanges(context, {
+    payment_currencies: [
+      {
+        name: 'recharge_config',
+        field: {
+          type: DataTypes.JSON,
+          allowNull: true,
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.dropTable('auto_recharge_configs');
+  await context.removeColumn('payment_currencies', 'recharge_config');
+};