payment-kit 1.13.174 → 1.13.176

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

@@ -41,7 +41,6 @@ import {
 import { CHECKOUT_SESSION_TTL, createCodeGenerator, formatMetadata, getDataObjectFromQuery } from '../libs/util';
 import { invoiceQueue } from '../queues/invoice';
 import { paymentQueue } from '../queues/payment';
-import { addSubscriptionJob } from '../queues/subscription';
 import type { TPriceExpanded, TProductExpanded } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
@@ -54,7 +53,7 @@ import { Product } from '../store/models/product';
 import { SetupIntent } from '../store/models/setup-intent';
 import { Subscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
-import { ensureInvoiceForCheckout, ensureSetupIntent } from './connect/shared';
+import { ensureInvoiceForCheckout } from './connect/shared';
 
 const getInvoicePrefix = createCodeGenerator('', 8);
 
@@ -464,6 +463,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
     const lineItems = await Price.expand(checkoutSession.line_items, { product: true, upsell: true });
     const trialInDays = Number(checkoutSession.subscription_data?.trial_period_days || 0);
     const trialEnds = Number(checkoutSession.subscription_data?.trial_end || 0);
+    const billingThreshold = Number(checkoutSession.subscription_data?.billing_threshold_amount || 0);
     const amount = getCheckoutAmount(lineItems, paymentCurrency.id, !!trialInDays);
     await checkoutSession.update({
       amount_subtotal: amount.subtotal,
@@ -675,8 +675,8 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
             },
           },
           // @ts-ignore
-          billing_thresholds: checkoutSession.subscription_data?.billing_threshold_amount
-            ? { amount_gte: checkoutSession.subscription_data.billing_threshold_amount, reset_billing_cycle_anchor: false } // prettier-ignore
+          billing_thresholds: billingThreshold
+            ? { amount_gte: billingThreshold, reset_billing_cycle_anchor: false } // prettier-ignore
             : null,
           pending_invoice_item_interval: setup.recurring,
           pending_setup_intent: setupIntent?.id,
@@ -688,9 +688,9 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
             formatSubscriptionProduct(lineItems.filter((x) => x.price.type === 'recurring')),
           proration_behavior: checkoutSession.subscription_data?.proration_behavior || 'none',
           payment_behavior: 'default_incomplete',
-          days_until_due: checkoutSession.subscription_data?.days_until_due || checkoutSession.metadata?.days_until_due,
+          days_until_due: checkoutSession.subscription_data?.days_until_due ?? checkoutSession.metadata?.days_until_due,
           days_until_cancel:
-            checkoutSession.subscription_data?.days_until_cancel || checkoutSession.metadata?.days_until_cancel,
+            checkoutSession.subscription_data?.days_until_cancel ?? checkoutSession.metadata?.days_until_cancel,
           metadata: checkoutSession.metadata as any,
         });
 
@@ -775,38 +775,6 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       }
     }
 
-    // all subscription payments are done after delegation
-    if (checkoutSession.mode === 'subscription' && subscription) {
-      if (
-        delegation.sufficient || // we can pay from delegation
-        (balance.sufficient && ['NO_TOKEN', 'NO_ENOUGH_TOKEN'].includes(delegation.reason as string)) // we can pay from balance
-      ) {
-        await subscription.update({ payment_settings: paymentSettings });
-
-        const { invoice } = await ensureInvoiceForCheckout({ checkoutSession, customer, subscription });
-        if (invoice) {
-          invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
-        }
-        addSubscriptionJob(subscription, 'cycle', false, subscription.trial_end);
-      }
-    }
-
-    if (checkoutSession.mode === 'setup' && setupIntent && subscription) {
-      if (delegation.sufficient) {
-        const { invoice } = await ensureSetupIntent(checkoutSession.id, customer.did);
-        if (invoice) {
-          await invoiceQueue.pushAndWait({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
-        }
-        await setupIntent.update({ status: 'succeeded', ...paymentSettings });
-        await subscription.update({
-          status: subscription.trial_end ? 'trialing' : 'active',
-          payment_settings: paymentSettings,
-        });
-        await checkoutSession.update({ status: 'complete', payment_status: 'no_payment_required' });
-        logger.info(`CheckoutSession ${checkoutSession.id} updated on setup done ${setupIntent.id}`);
-      }
-    }
-
     let stripeContext: any = null;
     if (paymentMethod.type === 'stripe') {
       if (paymentIntent) {
@@ -858,8 +826,8 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       subscription,
       checkoutSession,
       customer,
-      delegation,
-      balance,
+      delegation: checkoutSession.mode === 'payment' ? delegation : null,
+      balance: checkoutSession.mode === 'payment' ? balance : null,
     });
   } catch (err) {
     console.error(err);

package/api/src/routes/connect/change-payment.ts

@@ -1,12 +1,15 @@
-import { toTypeInfo } from '@arcblock/did';
-import type { Transaction } from '@ocap/client';
-import { fromPublicKey } from '@ocap/wallet';
-
 import type { CallbackArgs } from '../../libs/auth';
-import { getGasPayerExtra } from '../../libs/payment';
+import { isDelegationSufficientForPayment } from '../../libs/payment';
+import { getFastCheckoutAmount } from '../../libs/session';
 import { getTxMetadata } from '../../libs/util';
 import type { TLineItemExpanded } from '../../store/models';
-import { ensureChangePaymentContext, getAuthPrincipalClaim, getDelegationTxClaim } from './shared';
+import {
+  ensureChangePaymentContext,
+  executeOcapTransactions,
+  getAuthPrincipalClaim,
+  getDelegationTxClaim,
+  getStakeTxClaim,
+} from './shared';
 
 export default {
   action: 'change-payment',
@@ -19,25 +22,56 @@ export default {
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { subscription, paymentMethod, paymentCurrency } = await ensureChangePaymentContext(subscriptionId);
+    const { subscription, customer, paymentMethod, paymentCurrency } = await ensureChangePaymentContext(subscriptionId);
 
     if (paymentMethod.type === 'arcblock') {
+      const claims: { [type: string]: [string, object] } = {};
+
       // @ts-ignore
       const items = subscription!.items as TLineItemExpanded[];
+      const trialInDays = 0;
+      const billingThreshold = Number(subscription.billing_thresholds?.amount_gte || 0);
+      const fastCheckoutAmount = getFastCheckoutAmount(items, 'setup', paymentCurrency.id, !!trialInDays);
+      const delegation = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: customer!.did,
+        amount: fastCheckoutAmount,
+      });
+
+      // if we can complete purchase without any wallet interaction
+      if (delegation.sufficient === false) {
+        claims.delegation = [
+          'signature',
+          await getDelegationTxClaim({
+            mode: 'setup',
+            userDid,
+            userPk,
+            nonce: `change-method-${subscription.id}`,
+            data: getTxMetadata({ subscriptionId: subscription.id }),
+            paymentCurrency,
+            paymentMethod,
+            trialInDays,
+            billingThreshold,
+            items,
+          }),
+        ];
+      }
 
-      return {
-        signature: await getDelegationTxClaim({
-          mode: 'setup',
+      // we always need to stake for the subscription
+      claims.staking = [
+        'prepareTx',
+        await getStakeTxClaim({
           userDid,
           userPk,
-          nonce: subscription!.id,
-          data: getTxMetadata({ subscriptionId: subscription!.id }),
           paymentCurrency,
           paymentMethod,
-          trial: false,
           items,
+          subscription,
         }),
-      };
+      ];
+
+      return claims;
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);
@@ -52,27 +86,14 @@ export default {
     if (paymentMethod.type === 'arcblock') {
       await subscription?.update({
         payment_settings: {
-          payment_method_types: ['arcblock'],
+          payment_method_types: [paymentMethod.type],
           payment_method_options: {
             arcblock: { payer: userDid },
           },
         },
       });
 
-      const client = paymentMethod.getOcapClient();
-      const claim = claims.find((x) => x.type === 'signature');
-
-      // execute the delegate tx
-      const tx: Partial<Transaction> = client.decodeTx(claim.origin);
-      tx.signature = claim.sig;
-
-      // @ts-ignore
-      const { buffer } = await client.encodeDelegateTx({ tx });
-      const txHash = await client.sendDelegateTx(
-        // @ts-ignore
-        { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
-        getGasPayerExtra(buffer)
-      );
+      const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod);
 
       await setupIntent.update({
         status: 'succeeded',
@@ -82,23 +103,16 @@ export default {
           arcblock: { payer: userDid },
         },
         setup_details: {
-          arcblock: {
-            tx_hash: txHash,
-            payer: userDid,
-          },
+          arcblock: paymentDetails,
         },
       });
 
       await subscription?.update({
         currency_id: paymentCurrency.id,
         default_payment_method_id: paymentMethod.id,
-        payment_settings: {
-          payment_method_types: [paymentMethod.type],
-          payment_method_options: {},
-        },
       });
 
-      return { hash: txHash };
+      return { hash: paymentDetails.tx_hash };
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);

package/api/src/routes/connect/change-plan.ts

@@ -1,14 +1,17 @@
-import { toTypeInfo } from '@arcblock/did';
-import type { Transaction } from '@ocap/client';
-import { fromPublicKey } from '@ocap/wallet';
-
 import type { CallbackArgs } from '../../libs/auth';
-import { getGasPayerExtra } from '../../libs/payment';
+import { isDelegationSufficientForPayment } from '../../libs/payment';
+import { getFastCheckoutAmount } from '../../libs/session';
 import { getTxMetadata } from '../../libs/util';
 import { invoiceQueue } from '../../queues/invoice';
 import { addSubscriptionJob } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
-import { ensureSubscription, getAuthPrincipalClaim, getDelegationTxClaim } from './shared';
+import {
+  ensureSubscription,
+  executeOcapTransactions,
+  getAuthPrincipalClaim,
+  getDelegationTxClaim,
+  getStakeTxClaim,
+} from './shared';
 
 export default {
   action: 'change-plan',
@@ -21,25 +24,56 @@ export default {
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { subscriptionId } = extraParams;
-    const { paymentMethod, paymentCurrency, subscription } = await ensureSubscription(subscriptionId);
+    const { paymentMethod, paymentCurrency, subscription, customer } = await ensureSubscription(subscriptionId);
 
     if (paymentMethod.type === 'arcblock') {
+      const claims: { [type: string]: [string, object] } = {};
+
       // @ts-ignore
       const items = subscription!.items as TLineItemExpanded[];
+      const trialInDays = 0;
+      const billingThreshold = Number(subscription!.billing_thresholds?.amount_gte || 0);
+      const fastCheckoutAmount = getFastCheckoutAmount(items, 'subscription', paymentCurrency.id, !!trialInDays);
+      const delegation = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: customer!.did,
+        amount: fastCheckoutAmount,
+      });
+
+      // if we can complete purchase without any wallet interaction
+      if (delegation.sufficient === false) {
+        claims.delegation = [
+          'signature',
+          await getDelegationTxClaim({
+            mode: 'subscription',
+            userDid,
+            userPk,
+            nonce: `change-plan-${subscription!.id}`,
+            data: getTxMetadata({ subscriptionId: subscription!.id }),
+            paymentCurrency,
+            paymentMethod,
+            trialInDays,
+            billingThreshold,
+            items,
+          }),
+        ];
+      }
 
-      return {
-        signature: await getDelegationTxClaim({
-          mode: 'subscription',
+      // we always need to stake for the subscription
+      claims.staking = [
+        'prepareTx',
+        await getStakeTxClaim({
           userDid,
           userPk,
-          nonce: subscription!.id,
-          data: getTxMetadata({ subscriptionId: subscription!.id }),
           paymentCurrency,
           paymentMethod,
-          trial: false,
           items,
+          subscription: subscription!,
         }),
-      };
+      ];
+
+      return claims;
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);
@@ -59,35 +93,13 @@ export default {
         },
       });
 
-      const client = paymentMethod.getOcapClient();
-      const claim = claims.find((x) => x.type === 'signature');
-
-      // execute the delegate tx
-      const tx: Partial<Transaction> = client.decodeTx(claim.origin);
-      tx.signature = claim.sig;
-
-      // @ts-ignore
-      const { buffer } = await client.encodeDelegateTx({ tx });
-      const txHash = await client.sendDelegateTx(
-        // @ts-ignore
-        { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
-        getGasPayerExtra(buffer)
-      );
-
-      await subscription?.update({
-        payment_details: {
-          arcblock: {
-            tx_hash: txHash,
-            payer: userDid,
-          },
-        },
-      });
+      const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod);
+      await subscription?.update({ payment_details: { arcblock: paymentDetails } });
 
       if (invoice) {
         if (invoice.status === 'uncollectible') {
           await invoice.update({ status: 'open' });
         }
-
         await invoiceQueue.pushAndWait({
           id: invoice.id,
           job: { invoiceId: invoice.id, retryOnError: false, waitForPayment: true },
@@ -97,7 +109,7 @@ export default {
         await addSubscriptionJob(subscription, 'cycle', false, subscription.trial_end);
       }
 
-      return { hash: txHash };
+      return { hash: paymentDetails.tx_hash };
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);

package/api/src/routes/connect/collect-batch.ts

@@ -98,6 +98,7 @@ export default {
             arcblock: {
               tx_hash: txHash,
               payer: userDid,
+              type: 'transfer',
             },
           },
         });

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

@@ -58,7 +58,7 @@ export default {
           userPk,
           nonce: invoice.id,
           data: getTxMetadata({ subscriptionId: subscription!.id, invoiceId: invoice.id }),
-          trial: false,
+          trialInDays: 0,
           paymentCurrency,
           paymentMethod,
           items,
@@ -102,6 +102,7 @@ export default {
           arcblock: {
             tx_hash: txHash,
             payer: userDid,
+            type: 'transfer',
           },
         },
       });

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

@@ -90,6 +90,7 @@ export default {
           arcblock: {
             tx_hash: txHash,
             payer: userDid,
+            type: 'transfer',
           },
         },
       });

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

@@ -1,14 +1,18 @@
-import { toTypeInfo } from '@arcblock/did';
-import type { Transaction } from '@ocap/client';
-import { fromPublicKey } from '@ocap/wallet';
-
 import type { CallbackArgs } from '../../libs/auth';
-import { getGasPayerExtra } from '../../libs/payment';
+import logger from '../../libs/logger';
+import { isDelegationSufficientForPayment } from '../../libs/payment';
+import { getFastCheckoutAmount } from '../../libs/session';
 import { getTxMetadata } from '../../libs/util';
 import { invoiceQueue } from '../../queues/invoice';
 import { addSubscriptionJob } from '../../queues/subscription';
 import type { TLineItemExpanded } from '../../store/models';
-import { ensureSetupIntent, getAuthPrincipalClaim, getDelegationTxClaim } from './shared';
+import {
+  ensureSetupIntent,
+  executeOcapTransactions,
+  getAuthPrincipalClaim,
+  getDelegationTxClaim,
+  getStakeTxClaim,
+} from './shared';
 
 export default {
   action: 'setup',
@@ -21,7 +25,7 @@ export default {
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { checkoutSessionId } = extraParams;
-    const { paymentMethod, paymentCurrency, checkoutSession, subscription } = await ensureSetupIntent(
+    const { paymentMethod, paymentCurrency, checkoutSession, subscription, customer } = await ensureSetupIntent(
       checkoutSessionId,
       userDid
     );
@@ -30,20 +34,51 @@ export default {
     }
 
     if (paymentMethod.type === 'arcblock') {
+      const claims: { [type: string]: [string, object] } = {};
+
+      // if we can complete purchase without any wallet interaction
       const items = checkoutSession.line_items as TLineItemExpanded[];
-      return {
-        signature: await getDelegationTxClaim({
-          mode: checkoutSession.mode,
+      const trialInDays = Number(checkoutSession.subscription_data?.trial_period_days || 0);
+      const billingThreshold = Number(checkoutSession.subscription_data?.billing_threshold_amount || 0);
+      const fastCheckoutAmount = getFastCheckoutAmount(items, checkoutSession.mode, paymentCurrency.id, !!trialInDays);
+      const delegation = await isDelegationSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: customer.did,
+        amount: fastCheckoutAmount,
+      });
+      if (delegation.sufficient === false) {
+        claims.delegation = [
+          'signature',
+          await getDelegationTxClaim({
+            mode: checkoutSession.mode,
+            userDid,
+            userPk,
+            nonce: checkoutSession.id,
+            data: getTxMetadata({ subscriptionId: subscription.id, checkoutSessionId }),
+            paymentCurrency,
+            paymentMethod,
+            trialInDays,
+            billingThreshold,
+            items,
+          }),
+        ];
+      }
+
+      // we always need to stake for the subscription
+      claims.staking = [
+        'prepareTx',
+        await getStakeTxClaim({
           userDid,
           userPk,
-          nonce: checkoutSession.id,
-          data: getTxMetadata({ subscriptionId: subscription.id, checkoutSessionId }),
           paymentCurrency,
           paymentMethod,
-          trial: !!checkoutSession.subscription_data?.trial_period_days,
           items,
+          subscription,
         }),
-      };
+      ];
+
+      return claims;
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);
@@ -60,63 +95,42 @@ export default {
     }
 
     if (paymentMethod.type === 'arcblock') {
-      await setupIntent.update({ status: 'processing' });
-      await subscription.update({
-        payment_settings: {
-          payment_method_types: ['arcblock'],
-          payment_method_options: {
-            arcblock: { payer: userDid },
-          },
+      const paymentSettings = {
+        payment_method_types: ['arcblock'],
+        payment_method_options: {
+          arcblock: { payer: userDid },
         },
-      });
-
-      const client = paymentMethod.getOcapClient();
-      const claim = claims.find((x) => x.type === 'signature');
-
-      // execute the delegate tx
-      const tx: Partial<Transaction> = client.decodeTx(claim.origin);
-      tx.signature = claim.sig;
-
-      // @ts-ignore
-      const { buffer } = await client.encodeDelegateTx({ tx });
-      const txHash = await client.sendDelegateTx(
-        // @ts-ignore
-        { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
-        getGasPayerExtra(buffer)
-      );
+      };
+      await setupIntent.update({ status: 'processing' });
+      await subscription.update({ payment_settings: paymentSettings });
+      if (invoice) {
+        await invoice.update({ payment_settings: paymentSettings });
+      }
 
+      const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod);
       await setupIntent.update({
         status: 'succeeded',
         last_setup_error: null,
-        payment_method_types: ['arcblock'],
-        payment_method_options: {
-          arcblock: { payer: userDid },
-        },
-        setup_details: {
-          arcblock: {
-            tx_hash: txHash,
-            payer: userDid,
-          },
-        },
+        setup_details: { arcblock: paymentDetails },
+        ...paymentSettings,
       });
-
       await subscription.update({
         status: subscription.trial_end ? 'trialing' : 'active',
-        payment_details: {
-          arcblock: {
-            tx_hash: txHash,
-            payer: userDid,
-          },
-        },
+        payment_details: { arcblock: paymentDetails },
       });
 
       await checkoutSession.update({ status: 'complete', payment_status: 'paid' });
       if (invoice) {
-        invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
+        invoiceQueue.pushAndWait({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
       }
       await addSubscriptionJob(subscription, 'cycle', false, subscription.trial_end);
+      logger.info('CheckoutSession updated on setup done', {
+        checkoutSession: checkoutSession.id,
+        setupIntent: setupIntent.id,
+        paymentDetails,
+      });
 
-      return { hash: txHash };
+      return { hash: paymentDetails.tx_hash };
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);