payment-kit 1.21.16 → 1.22.0

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

@@ -270,11 +270,12 @@ export async function ensureSetupIntent(checkoutSessionId: string, skipInvoice?:
       invoice = await Invoice.findByPk(checkoutSession.invoice_id);
     } else {
       // Get discount information for this checkout session
-      let discountInfo: { appliedDiscounts: string[]; discountBreakdown: Array<{ amount: string; discount: string }> } = { 
-        appliedDiscounts: [], 
-        discountBreakdown: [] 
-      };
-      
+      let discountInfo: { appliedDiscounts: string[]; discountBreakdown: Array<{ amount: string; discount: string }> } =
+        {
+          appliedDiscounts: [],
+          discountBreakdown: [],
+        };
+
       try {
         discountInfo = await getDiscountRecordsForCheckout({
           checkoutSessionId: checkoutSession.id,
@@ -462,13 +463,13 @@ export async function ensureInvoiceForCheckout({
   const trialEnd = Number(checkoutSession.subscription_data?.trial_end || 0);
   const now = dayjs().unix();
   const invoiceItems = lineItems || (await Price.expand(checkoutSession.line_items, { product: true }));
-  
+
   // Get discount records for this checkout session
-  let discountInfo: { appliedDiscounts: string[]; discountBreakdown: Array<{ amount: string; discount: string }> } = { 
-    appliedDiscounts: [], 
-    discountBreakdown: [] 
+  let discountInfo: { appliedDiscounts: string[]; discountBreakdown: Array<{ amount: string; discount: string }> } = {
+    appliedDiscounts: [],
+    discountBreakdown: [],
   };
-  
+
   // Prepare discount configuration for getCheckoutAmount
   let discountConfig;
   try {
@@ -476,7 +477,7 @@ export async function ensureInvoiceForCheckout({
       checkoutSessionId: checkoutSession.id,
       customerId: customer.id,
     });
-    
+
     // Apply discount if we have discount records
     if (discountInfo.appliedDiscounts.length > 0 && checkoutSession.discounts?.length) {
       const firstDiscount = checkoutSession.discounts[0];
@@ -495,8 +496,13 @@ export async function ensureInvoiceForCheckout({
       error: error.message,
     });
   }
-  
-  const totalAmount = await getCheckoutAmount(invoiceItems, checkoutSession.currency_id, trialInDays > 0 || trialEnd > now, discountConfig);
+
+  const totalAmount = await getCheckoutAmount(
+    invoiceItems,
+    checkoutSession.currency_id,
+    trialInDays > 0 || trialEnd > now,
+    discountConfig
+  );
   const { invoice, items } = await ensureInvoiceAndItems({
     customer,
     currency: currency as PaymentCurrency,
@@ -530,16 +536,16 @@ export async function ensureInvoiceForCheckout({
       custom_fields: checkoutSession.invoice_creation?.invoice_data?.custom_fields || [],
       footer: checkoutSession.invoice_creation?.invoice_data?.footer || '',
       metadata,
-      
+
       discounts: discountInfo.appliedDiscounts,
       total_discount_amounts: discountInfo.discountBreakdown,
-      
+
       ...(props || {}),
     } as unknown as Invoice,
   });
-  
-  logger.info('Invoice created for checkoutSession', { 
-    checkoutSessionId: checkoutSession.id, 
+
+  logger.info('Invoice created for checkoutSession', {
+    checkoutSessionId: checkoutSession.id,
     invoiceId: invoice.id,
     hasDiscounts: discountInfo.appliedDiscounts.length > 0,
     discountCount: discountInfo.appliedDiscounts.length,
@@ -696,7 +702,7 @@ export async function ensureAccountRecharge(customerId: string, currencyId: stri
   }
 
   const receiverAddress = rechargeAddress || customer.did;
-  
+
   return {
     paymentCurrency: paymentCurrency as PaymentCurrency,
     paymentMethod: paymentMethod as PaymentMethod,
@@ -1084,7 +1090,8 @@ export async function getTokenRequirements({
   const tokenRequirements: { address: string; value: string }[] = [];
   let amount = await getFastCheckoutAmount({ items, mode, currencyId: paymentCurrency.id, trialing: !!trialing });
 
-  const addStakeRequired = requiredStake && ((paymentMethod.type === 'arcblock' && mode !== 'delegation') || mode === 'setup');
+  const addStakeRequired =
+    requiredStake && ((paymentMethod.type === 'arcblock' && mode !== 'delegation') || mode === 'setup');
 
   if (!addStakeRequired && amount === '0') {
     return tokenRequirements;
@@ -1123,7 +1130,10 @@ export async function getTokenRequirements({
     if (exist) {
       exist.value = new BN(exist.value).add(staking.licensed).add(staking.metered).toString();
     } else {
-      tokenRequirements.push({ address: paymentCurrency.contract as string, value: staking.licensed.add(staking.metered).toString() });
+      tokenRequirements.push({
+        address: paymentCurrency.contract as string,
+        value: staking.licensed.add(staking.metered).toString(),
+      });
     }
   }
 
@@ -1224,6 +1234,36 @@ export async function ensureChangePaymentContext(subscriptionId: string) {
   };
 }
 
+export async function ensurePayerChangeContext(subscriptionId: string) {
+  const subscription = await Subscription.findByPk(subscriptionId);
+  if (!subscription) {
+    throw new Error(`Subscription not found: ${subscriptionId}`);
+  }
+  if (!['active', 'trialing', 'past_due'].includes(subscription.status)) {
+    throw new Error(`Subscription ${subscriptionId} is not in a valid status to change payer`);
+  }
+  const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+  if (!paymentMethod) {
+    throw new Error(`Payment method not found for subscription ${subscriptionId}`);
+  }
+  const payerAddress = getSubscriptionPaymentAddress(subscription, paymentMethod?.type);
+  const paymentCurrency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!paymentCurrency) {
+    throw new Error(`PaymentCurrency ${subscription.currency_id} not found for subscription ${subscriptionId}`);
+  }
+
+  // @ts-ignore
+  subscription.items = await expandSubscriptionItems(subscription.id);
+
+  return {
+    subscription,
+    paymentCurrency,
+    paymentMethod,
+    customer: await Customer.findByPk(subscription.customer_id),
+    payerAddress,
+  };
+}
+
 export async function ensureReStakeContext(subscriptionId: string) {
   const subscription = await Subscription.findByPk(subscriptionId);
   if (!subscription) {
@@ -1378,7 +1418,7 @@ async function executeSingleTransaction(
   const { buffer } = await client[`encode${type}Tx`]({ tx });
   return client[`send${type}Tx`](
     { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
-    getGasPayerExtra(buffer, gasPayerHeaders)
+    await getGasPayerExtra(buffer, gasPayerHeaders)
   );
 }
 
@@ -1501,7 +1541,6 @@ export async function updateStripeSubscriptionAfterChangePayment(setupIntent: Se
   }
 }
 
-
 export async function ensureAutoRechargeAuthorization(
   autoRechargeConfigId: string
 ): Promise<{ autoRechargeConfig: AutoRechargeConfig; paymentMethod: PaymentMethod; paymentCurrency: PaymentCurrency }> {

package/api/src/routes/customers.ts

@@ -1,4 +1,4 @@
-import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
+import { sessionMiddleware } from '@blocklet/sdk/lib/middlewares/session';
 import { Router } from 'express';
 import Joi from 'joi';
 import pick from 'lodash/pick';

package/api/src/routes/integrations/stripe.ts

@@ -1,4 +1,4 @@
-import env from '@blocklet/sdk/lib/env';
+import { env } from '@blocklet/sdk/lib/env';
 import express, { NextFunction, Request, Response, Router } from 'express';
 import get from 'lodash/get';
 

package/api/src/routes/invoices.ts

@@ -8,6 +8,7 @@ import { Op } from 'sequelize';
 import { BN } from '@ocap/util';
 import { syncStripeInvoice } from '../integrations/stripe/handlers/invoice';
 import { syncStripePayment } from '../integrations/stripe/handlers/payment-intent';
+import { ensureStripeCustomer, ensureStripeSetupIntentForInvoicePayment } from '../integrations/stripe/resource';
 import { createListParamSchema, getOrder, getWhereFromKvQuery, MetadataSchema } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
@@ -662,9 +663,11 @@ router.get('/:id', authPortal, async (req, res) => {
     })) as TInvoiceExpanded | null;
 
     if (doc) {
-      if (doc.metadata?.stripe_id && (doc.status !== 'paid' || req.query.forceSync)) {
+      const shouldSync = req.query.sync === 'true' || !!req.query.forceSync;
+      // Sync Stripe invoice when sync=true query parameter is present
+      if (doc.metadata?.stripe_id && doc.status !== 'paid') {
         // @ts-ignore
-        await syncStripeInvoice(doc);
+        await syncStripeInvoice(doc, shouldSync);
       }
       if (doc.payment_intent_id) {
         const paymentIntent = await PaymentIntent.findByPk(doc.payment_intent_id);
@@ -799,6 +802,142 @@ router.get('/:id', authPortal, async (req, res) => {
   }
 });
 
+router.post('/pay-stripe', authPortal, async (req, res) => {
+  try {
+    const { invoice_ids, subscription_id, customer_id, currency_id } = req.body;
+
+    if (!currency_id) {
+      return res.status(400).json({ error: 'currency_id is required' });
+    }
+
+    if (!invoice_ids && !subscription_id && !customer_id) {
+      return res.status(400).json({ error: 'Must provide invoice_ids, subscription_id, or customer_id' });
+    }
+
+    let invoices: Invoice[];
+    let customer: Customer | null;
+    let paymentMethod: PaymentMethod | null = null;
+
+    if (invoice_ids && Array.isArray(invoice_ids) && invoice_ids.length > 0) {
+      invoices = await Invoice.findAll({
+        where: {
+          id: { [Op.in]: invoice_ids },
+          currency_id,
+          status: { [Op.in]: ['open', 'uncollectible'] },
+        },
+        include: [
+          { model: Customer, as: 'customer' },
+          { model: PaymentCurrency, as: 'paymentCurrency' },
+        ],
+      });
+
+      if (invoices.length === 0) {
+        return res.status(404).json({ error: 'No payable invoices found' });
+      }
+
+      // @ts-ignore
+      customer = invoices[0]?.customer;
+      paymentMethod = await PaymentMethod.findByPk(invoices[0]!.default_payment_method_id);
+    } else if (subscription_id) {
+      const subscription = await Subscription.findByPk(subscription_id, {
+        include: [{ model: Customer, as: 'customer' }],
+      });
+
+      if (!subscription) {
+        return res.status(404).json({ error: 'Subscription not found' });
+      }
+
+      // @ts-ignore
+      customer = subscription.customer;
+      paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+
+      invoices = await Invoice.findAll({
+        where: {
+          subscription_id,
+          currency_id,
+          status: { [Op.in]: ['open', 'uncollectible'] },
+        },
+        include: [
+          { model: Customer, as: 'customer' },
+          { model: PaymentCurrency, as: 'paymentCurrency' },
+        ],
+      });
+    } else {
+      customer = await Customer.findByPkOrDid(customer_id!);
+      if (!customer) {
+        return res.status(404).json({ error: 'Customer not found' });
+      }
+
+      invoices = await Invoice.findAll({
+        where: {
+          customer_id: customer.id,
+          currency_id,
+          status: { [Op.in]: ['open', 'uncollectible'] },
+        },
+        include: [
+          { model: Customer, as: 'customer' },
+          { model: PaymentCurrency, as: 'paymentCurrency' },
+        ],
+      });
+
+      if (invoices.length === 0) {
+        return res.status(404).json({ error: 'No payable invoices found' });
+      }
+
+      paymentMethod = await PaymentMethod.findByPk(invoices[0]!.default_payment_method_id);
+    }
+
+    if (!customer) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+
+    if (!paymentMethod || paymentMethod.type !== 'stripe') {
+      return res.status(400).json({ error: 'Not using Stripe payment method' });
+    }
+
+    if (invoices.length === 0) {
+      return res.status(400).json({ error: 'No payable invoices found' });
+    }
+
+    await ensureStripeCustomer(customer, paymentMethod);
+
+    const settings = PaymentMethod.decryptSettings(paymentMethod.settings);
+
+    const paymentCurrency = await PaymentCurrency.findByPk(currency_id);
+    if (!paymentCurrency) {
+      return res.status(404).json({ error: `Payment currency ${currency_id} not found` });
+    }
+    const totalAmount = invoices.reduce((sum, invoice) => {
+      const amount = invoice.amount_remaining || '0';
+      return new BN(sum).add(new BN(amount)).toString();
+    }, '0');
+
+    const metadata: any = {
+      currency_id,
+      customer_id: customer.id,
+      invoices: JSON.stringify(invoices.map((inv) => inv.id)),
+    };
+
+    const setupIntent = await ensureStripeSetupIntentForInvoicePayment(customer, paymentMethod, metadata);
+
+    return res.json({
+      client_secret: setupIntent.client_secret,
+      publishable_key: settings.stripe?.publishable_key,
+      setup_intent_id: setupIntent.id,
+      invoices: invoices.map((inv) => inv.id),
+      amount: totalAmount,
+      currency: paymentCurrency,
+      customer,
+    });
+  } catch (err) {
+    logger.error('Failed to create setup intent for stripe payment', {
+      error: err,
+      body: req.body,
+    });
+    return res.status(400).json({ error: err.message });
+  }
+});
+
 // eslint-disable-next-line consistent-return
 router.put('/:id', authAdmin, async (req, res) => {
   try {

package/api/src/routes/meter-events.ts

@@ -278,7 +278,7 @@ router.post('/', auth, async (req, res) => {
         value: fromTokenToUnit(value, paymentCurrency.decimal).toString(),
       },
       identifier: req.body.identifier,
-      livemode: !!req.livemode,
+      livemode: meter.livemode,
       processed: false,
       status: 'pending' as MeterEventStatus,
       attempt_count: 0,
@@ -312,12 +312,15 @@ router.post('/', auth, async (req, res) => {
 
 router.get('/pending-amount', authMine, async (req, res) => {
   try {
-    const where: any = {
-      status: 'requires_action',
+    const params: any = {
+      status: ['requires_action', 'requires_capture'],
       livemode: !!req.livemode,
     };
     if (req.query.subscription_id) {
-      where['payload.subscription_id'] = req.query.subscription_id;
+      params.subscriptionId = req.query.subscription_id;
+    }
+    if (req.query.currency_id) {
+      params.currencyId = req.query.currency_id;
     }
     if (req.query.customer_id) {
       if (typeof req.query.customer_id !== 'string') {
@@ -327,15 +330,9 @@ router.get('/pending-amount', authMine, async (req, res) => {
       if (!customer) {
         return res.status(404).json({ error: 'Customer not found' });
       }
-      where['payload.customer_id'] = customer.id;
+      params.customerId = customer.id;
     }
-    const [summary] = await MeterEvent.getPendingAmounts({
-      subscriptionId: req.query.subscription_id as string,
-      livemode: !!req.livemode,
-      currencyId: req.query.currency_id as string,
-      status: ['requires_action', 'requires_capture'],
-      customerId: req.query.customer_id as string,
-    });
+    const [summary] = await MeterEvent.getPendingAmounts(params);
     return res.json(summary);
   } catch (err) {
     logger.error('Error getting meter event pending amount', err);

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

@@ -5,7 +5,7 @@ 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 { sessionMiddleware } from '@blocklet/sdk/lib/middlewares/session';
 import { fetchErc20Meta } from '../integrations/ethereum/token';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';

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

@@ -362,10 +362,10 @@ router.get('/:id/refundable-amount', authPortal, async (req, res) => {
       if (payouts.length > 0) {
         let totalPayoutAmount = new BN('0');
         payouts.forEach((payout) => {
-          totalPayoutAmount = totalPayoutAmount.add(new BN(payout.amount));
+          totalPayoutAmount = totalPayoutAmount.add(new BN(payout.amount || '0'));
         });
 
-        result.amount = result.amount.sub(totalPayoutAmount);
+        result.amount = new BN(result.amount || '0').sub(totalPayoutAmount).toString();
       }
       res.json(result);
     } else {

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

@@ -449,7 +449,8 @@ router.get('/:id/benefits', async (req, res) => {
     if (!doc) {
       return res.status(404).json({ error: 'payment link not found' });
     }
-    const benefits = await getDonationBenefits(doc);
+    const locale = req.query.locale as string;
+    const benefits = await getDonationBenefits(doc, '', locale);
     return res.json(benefits);
   } catch (err) {
     logger.error('Get donation benefits error', { error: err.message, stack: err.stack, id: req.params.id });

package/api/src/routes/payouts.ts

@@ -3,7 +3,7 @@ import { Router } from 'express';
 import Joi from 'joi';
 import pick from 'lodash/pick';
 
-import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
+import { sessionMiddleware } from '@blocklet/sdk/lib/middlewares/session';
 import type { WhereOptions } from 'sequelize';
 import { createListParamSchema, getOrder, getWhereFromKvQuery, MetadataSchema } from '../libs/api';
 import { authenticate } from '../libs/security';

package/api/src/routes/products.ts

@@ -166,6 +166,7 @@ export async function createProductAndPrices(payload: any) {
         // @ts-ignore
         ['preset', 'maximum', 'minimum'].forEach((key: keyof CustomUnitAmount) => {
           if (newPrice.custom_unit_amount?.[key]) {
+            // @ts-ignore
             newPrice.custom_unit_amount[key] = fromTokenToUnit(
               newPrice.custom_unit_amount[key] as string,
               currency.decimal

package/api/src/routes/subscriptions.ts

@@ -238,7 +238,7 @@ router.get('/search', auth, async (req, res) => {
 
 router.get('/:id', authPortal, async (req, res) => {
   try {
-    const doc = await Subscription.findOne({
+    const doc = (await Subscription.findOne({
       where: { id: req.params.id },
       include: [
         { model: PaymentCurrency, as: 'paymentCurrency' },
@@ -246,10 +246,15 @@ router.get('/:id', authPortal, async (req, res) => {
         { model: SubscriptionItem, as: 'items' },
         { model: Customer, as: 'customer' },
       ],
-    });
+    })) as Subscription & {
+      paymentMethod: PaymentMethod;
+      paymentCurrency: PaymentCurrency;
+      items: SubscriptionItem[];
+      customer: Customer;
+    };
 
     if (doc) {
-      const json = doc.toJSON();
+      const json: any = doc.toJSON();
       const isConsumesCredit = await doc.isConsumesCredit();
       const serviceType = isConsumesCredit ? 'credit' : 'standard';
       const products = (await Product.findAll()).map((x) => x.toJSON());
@@ -270,9 +275,70 @@ router.get('/:id', authPortal, async (req, res) => {
         logger.error('Failed to fetch subscription discount stats', { error, subscriptionId: json.id });
       }
 
+      // Get payment method details
+      let paymentMethodDetails = null;
+      try {
+        const paymentMethod = await PaymentMethod.findByPk(doc.default_payment_method_id);
+        if (paymentMethod?.type === 'stripe' && json.payment_details?.stripe?.subscription_id) {
+          const client = paymentMethod.getStripeClient();
+          const stripeSubscription = await client.subscriptions.retrieve(json.payment_details.stripe.subscription_id, {
+            expand: ['default_payment_method'],
+          });
+
+          if (stripeSubscription.default_payment_method) {
+            const paymentMethodId =
+              typeof stripeSubscription.default_payment_method === 'string'
+                ? stripeSubscription.default_payment_method
+                : stripeSubscription.default_payment_method.id;
+
+            const paymentMethodData = await client.paymentMethods.retrieve(paymentMethodId);
+
+            paymentMethodDetails = {
+              id: paymentMethodData.id,
+              type: paymentMethodData.type,
+              billing_details: paymentMethodData.billing_details,
+            } as any;
+
+            if (paymentMethodData.card) {
+              paymentMethodDetails.card = {
+                brand: paymentMethodData.card.brand,
+                last4: paymentMethodData.card.last4,
+                exp_month: paymentMethodData.card.exp_month,
+                exp_year: paymentMethodData.card.exp_year,
+              };
+            }
+
+            if (paymentMethodData.link) {
+              paymentMethodDetails.link = {
+                email: paymentMethodData.link.email,
+              };
+            }
+
+            if (paymentMethodData.us_bank_account) {
+              paymentMethodDetails.us_bank_account = {
+                account_type: paymentMethodData.us_bank_account.account_type,
+                bank_name: paymentMethodData.us_bank_account.bank_name,
+                last4: paymentMethodData.us_bank_account.last4,
+              };
+            }
+          }
+        } else if (doc.paymentMethod) {
+          const payer = getSubscriptionPaymentAddress(doc, doc.paymentMethod.type);
+          if (payer) {
+            paymentMethodDetails = {
+              type: doc.paymentMethod.type,
+              payer,
+            };
+          }
+        }
+      } catch (error) {
+        logger.error('Failed to fetch payment method details', { error, subscriptionId: json.id });
+      }
+
       res.json({
         ...json,
         discountStats,
+        paymentMethodDetails,
       });
     } else {
       res.status(404).json(null);
@@ -2283,4 +2349,65 @@ router.get('/:id/change-payment/migrate-invoice', auth, async (req, res) => {
     return res.status(400).json({ error: error.message });
   }
 });
+
+router.post('/:id/update-stripe-payment-method', authPortal, async (req, res) => {
+  try {
+    const subscription = await Subscription.findByPk(req.params.id);
+    if (!subscription) {
+      return res.status(404).json({ error: 'Subscription not found' });
+    }
+
+    if (!['active', 'trialing', 'past_due'].includes(subscription.status)) {
+      return res.status(400).json({ error: 'Subscription is not active' });
+    }
+
+    const paymentMethod = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+    if (!paymentMethod || paymentMethod.type !== 'stripe') {
+      return res.status(400).json({ error: 'Subscription is not using Stripe payment method' });
+    }
+
+    const stripeSubscriptionId = subscription.payment_details?.stripe?.subscription_id;
+    if (!stripeSubscriptionId) {
+      return res.status(400).json({ error: 'Stripe subscription not found' });
+    }
+
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+
+    await ensureStripeCustomer(customer, paymentMethod);
+
+    const client = paymentMethod.getStripeClient();
+    const settings = PaymentMethod.decryptSettings(paymentMethod.settings);
+
+    const setupIntent = await client.setupIntents.create({
+      customer: subscription.payment_details?.stripe?.customer_id,
+      payment_method_types: ['card'],
+      usage: 'off_session',
+      metadata: {
+        subscription_id: subscription.id,
+        action: 'update_payment_method',
+      },
+    });
+
+    logger.info('Setup intent created for updating stripe payment method', {
+      subscription: subscription.id,
+      setupIntent: setupIntent.id,
+    });
+
+    return res.json({
+      client_secret: setupIntent.client_secret,
+      publishable_key: settings.stripe?.publishable_key,
+      setup_intent_id: setupIntent.id,
+    });
+  } catch (err) {
+    logger.error('Failed to create setup intent for updating payment method', {
+      error: err,
+      subscriptionId: req.params.id,
+    });
+    return res.status(400).json({ error: err.message });
+  }
+});
+
 export default router;

package/api/src/store/models/types.ts

@@ -137,7 +137,7 @@ export type SimpleCustomField = {
 };
 
 export type DiscountAmount = {
-  amount: number;
+  amount: string;
   discount?: string;
   promotion_code?: string;
   coupon?: string;

package/api/tests/setup.ts

@@ -0,0 +1,11 @@
+import { fromRandom } from '@ocap/wallet';
+import { types } from '@ocap/mcrypto';
+
+// Create a test wallet
+const wallet = fromRandom({
+  role: types.RoleType.ROLE_APPLICATION,
+});
+
+// Set missing environment variables that @blocklet/sdk jest-setup.js doesn't provide
+process.env.BLOCKLET_APP_PK = wallet.publicKey;
+process.env.BLOCKLET_APP_EK = wallet.secretKey; // EK (Encryption Key) uses secretKey

package/api/third.d.ts

@@ -2,8 +2,6 @@ declare module 'vite-plugin-blocklet';
 
 declare module '@blocklet/sdk/service/notification';
 
-declare module '@blocklet/sdk/service/auth';
-
 declare module 'express-history-api-fallback';
 
 declare module 'express-async-errors';

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

package/jest.config.js

@@ -6,8 +6,8 @@ module.exports = {
   coverageDirectory: 'coverage',
   restoreMocks: true,
   clearMocks: true,
-  globalSetup: '@blocklet/sdk/lib/util/jest-setup.js',
-  globalTeardown: '@blocklet/sdk/lib/util/jest-teardown.js',
+  globalSetup: '../../tools/jest-setup.js',
+  globalTeardown: '../../tools/jest-teardown.js',
   transform: {
     '^.+\\.ts?$': 'ts-jest',
   },