payment-kit 1.13.92 → 1.13.93

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

@@ -0,0 +1,134 @@
+import { toTypeInfo } from '@arcblock/did';
+import { toDelegateAddress } from '@arcblock/did-util';
+import type { Transaction } from '@ocap/client';
+import { fromPublicKey } from '@ocap/wallet';
+
+import type { CallbackArgs } from '../../libs/auth';
+import { wallet } from '../../libs/auth';
+import { getGasPayerExtra, getTokenLimitsForDelegation } from '../../libs/payment';
+import { getFastCheckoutAmount } from '../../libs/session';
+import { OCAP_PAYMENT_TX_TYPE, getTxMetadata } from '../../libs/util';
+import { invoiceQueue } from '../../queues/invoice';
+import { subscriptionQueue } from '../../queues/subscription';
+import type { TLineItemExpanded } from '../../store/models';
+import { ensureSubscription, getAuthPrincipalClaim, getTokenRequirements } from './shared';
+
+export default {
+  action: 'update',
+  authPrincipal: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureSubscription(extraParams.subscriptionId);
+      return getAuthPrincipalClaim(paymentMethod, 'pay');
+    },
+  },
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { paymentMethod, paymentCurrency, subscription } = await ensureSubscription(subscriptionId);
+
+    if (paymentMethod.type === 'arcblock') {
+      // @ts-ignore
+      const items = subscription!.items as TLineItemExpanded[];
+      const address = toDelegateAddress(userDid, wallet.address);
+      const amount = getFastCheckoutAmount(items, 'subscription', paymentCurrency.id);
+
+      const tokenLimits = await getTokenLimitsForDelegation(items, paymentMethod, paymentCurrency, address, amount);
+      const tokenRequirements = await getTokenRequirements({
+        items,
+        mode: 'subscription',
+        includeFreeTrial: false,
+        paymentMethod,
+        paymentCurrency,
+      });
+
+      return {
+        signature: {
+          type: 'DelegateTx',
+          description: `Sign the delegation to update subscription ${subscription?.id}`,
+          wallet: fromPublicKey(userPk, toTypeInfo(userDid)),
+          data: {
+            itx: {
+              address,
+              to: wallet.address,
+              ops: [{ typeUrl: OCAP_PAYMENT_TX_TYPE, limit: { tokens: tokenLimits, assets: [] } }],
+              data: getTxMetadata({ subscriptionId }),
+            },
+          },
+          nonce: subscriptionId,
+          requirement: {
+            tokens: tokenRequirements,
+          },
+          chainInfo: {
+            host: paymentMethod.settings?.arcblock?.api_host as string,
+            id: paymentMethod.settings?.arcblock?.chain_id as string,
+          },
+        },
+      };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+
+  onAuth: async ({ userDid, userPk, claims, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { invoice, paymentMethod, subscription } = await ensureSubscription(subscriptionId);
+
+    if (paymentMethod.type === 'arcblock') {
+      await subscription?.update({
+        payment_settings: {
+          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 subscription?.update({
+        payment_details: {
+          arcblock: {
+            tx_hash: txHash,
+            payer: userDid,
+          },
+        },
+      });
+
+      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 },
+        });
+      }
+      if (subscription) {
+        subscriptionQueue.push({
+          id: subscription.id,
+          job: { subscriptionId: subscription.id, action: 'cycle' },
+          // our next invoice should be generated at the end of current period, either trailing or normal
+          runAt: subscription.trail_end || subscription.current_period_end,
+        });
+      }
+
+      return { hash: txHash };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};

package/api/src/routes/pricing-table.ts

@@ -1,6 +1,7 @@
 import { getUrl } from '@blocklet/sdk/lib/component';
 import { Router } from 'express';
 import Joi from 'joi';
+import merge from 'lodash/merge';
 import pick from 'lodash/pick';
 import uniq from 'lodash/uniq';
 import type { WhereOptions } from 'sequelize';
@@ -10,7 +11,7 @@ import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
 import { isLineItemCurrencyAligned } from '../libs/session';
 import { getDaysUntilDue } from '../libs/subscription';
-import { formatMetadata, getMetadataFromQuery } from '../libs/util';
+import { getDataObjectFromQuery } from '../libs/util';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { Price } from '../store/models/price';
@@ -21,113 +22,10 @@ import { formatCheckoutSession } from './checkout-sessions';
 const router = Router();
 const auth = authenticate<PricingTable>({ component: true, roles: ['owner', 'admin'] });
 
-const formatPricingTable = (payload: any) => {
-  const raw: Partial<PricingTable> = Object.assign(
-    {
-      branding_settings: {
-        background_color: '#ffffff',
-        border_style: 'default',
-        button_color: '#0074d4',
-        font_family: 'default',
-      },
-    },
-    pick(payload, ['name', 'items', 'metadata', 'brand_settings'])
-  );
-
-  raw.items = raw.items?.map((x) => {
-    const item = Object.assign(
-      {
-        adjustable_quantity: {
-          enabled: false,
-          maximum: 1,
-          minimum: 0,
-        },
-        after_completion: {
-          type: 'hosted_confirmation',
-          hosted_confirmation: {
-            custom_message: '',
-          },
-        },
-        allow_promotion_codes: false,
-        customer_creation: 'always',
-        consent_collection: {
-          promotions: 'none',
-          terms_of_service: 'none',
-        },
-        invoice_creation: {
-          enabled: true,
-        },
-        phone_number_collection: {
-          enabled: false,
-        },
-        billing_address_collection: 'auto',
-        subscription_data: {
-          description: '',
-          trial_period_days: 0,
-        },
-        nft_mint_settings: {
-          enabled: false,
-          factory: '',
-        },
-        submit_type: 'auto',
-        cross_sell_behavior: 'auto',
-      },
-      pick(x, [
-        'adjustable_quantity',
-        'after_completion',
-        'allow_promotion_codes',
-        'billing_address_collection',
-        'consent_collection',
-        'cross_sell_behavior',
-        'custom_fields',
-        'highlight_text',
-        'is_highlight',
-        'nft_mint_settings',
-        'phone_number_collection',
-        'price_id',
-        'product_id',
-        'submit_type',
-        'subscription_data',
-      ])
-    );
-
-    if (item.adjustable_quantity?.enabled) {
-      item.adjustable_quantity.minimum = Number(item.adjustable_quantity?.minimum);
-      item.adjustable_quantity.maximum = Number(item.adjustable_quantity?.maximum);
-    }
-    if (item.after_completion?.type === 'hosted_confirmation') {
-      // @ts-ignore
-      item.after_completion.redirect = null;
-    }
-    if (item.after_completion?.type === 'redirect') {
-      // @ts-ignore
-      item.after_completion.hosted_confirmation = null;
-    }
-
-    return item;
-  });
-
-  if (payload.highlight && payload.highlight_product_id) {
-    raw.items?.forEach((x) => {
-      if (x.product_id === payload.highlight_product_id) {
-        x.is_highlight = x.product_id === payload.highlight_product_id;
-        x.highlight_text = payload.highlight_text || 'popular';
-      } else {
-        x.is_highlight = false;
-        x.highlight_text = 'popular';
-      }
-    });
-  }
-
-  raw.metadata = formatMetadata(raw.metadata);
-
-  return raw;
-};
-
 // FIXME: @wangshijun use schema validation
 // eslint-disable-next-line consistent-return
 router.post('/', auth, async (req, res) => {
-  const raw: Partial<PricingTable> = formatPricingTable(req.body);
+  const raw: Partial<PricingTable> = PricingTable.format(req.body);
   raw.active = true;
   raw.locked = false;
   raw.livemode = !!req.livemode;
@@ -210,19 +108,9 @@ router.get('/:id', async (req, res) => {
     return res.status(404).json({ error: 'pricing table not found' });
   }
 
-  const prices = await Price.findAll({ where: { id: uniq(doc.items.map((x) => x.price_id)) } });
-  const products = await Product.findAll({ where: { id: uniq(doc.items.map((x) => x.product_id)) } });
-
-  doc.items.forEach((i) => {
-    // @ts-ignore
-    i.price = prices.find((p) => p.id === i.price_id);
-    // @ts-ignore
-    i.product = products.find((p) => p.id === i.product_id);
-  });
-
   const currency = await PaymentCurrency.findOne({ where: { livemode: doc.livemode, is_base_currency: true } });
-
-  res.json({ ...doc.toJSON(), currency });
+  const expanded = await doc.expand();
+  res.json({ ...expanded, currency });
 });
 
 // update
@@ -240,7 +128,7 @@ router.put('/:id', auth, async (req, res) => {
   //   return res.status(403).json({ error: 'pricing table locked' });
   // }
 
-  await doc.update(formatPricingTable(Object.assign({}, doc.dataValues, req.body)));
+  await doc.update(PricingTable.format(Object.assign({}, doc.dataValues, req.body)));
 
   res.json(doc);
 });
@@ -293,7 +181,7 @@ router.post('/stash', auth, async (req, res) => {
 
     let doc = await PricingTable.findByPk(raw.id);
     if (doc) {
-      await doc.update({ ...formatPricingTable(req.body), metadata: raw.metadata, livemode: raw.livemode });
+      await doc.update({ ...PricingTable.format(req.body), metadata: raw.metadata, livemode: raw.livemode });
     } else {
       doc = await PricingTable.create(raw as PricingTable);
     }
@@ -337,11 +225,11 @@ router.post('/:id/checkout/:priceId', async (req, res) => {
       'submit_type',
       'cross_sell_behavior',
       'nft_mint_settings',
-      'subscription_data',
     ]),
+    subscription_data: merge(price.subscription_data || {}, getDataObjectFromQuery(req.query, 'subscription_data')),
     metadata: {
       ...doc.metadata,
-      ...getMetadataFromQuery(req.query),
+      ...getDataObjectFromQuery(req.query),
       days_until_due: getDaysUntilDue(req.query),
       passport: await checkPassportForPricingTable(doc),
       pricing_table_id: doc.id,