payment-kit 1.13.15

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

@@ -0,0 +1,109 @@
+import type { Transaction, TransferV3Tx } from '@ocap/client';
+import { fromAddress } from '@ocap/wallet';
+
+import { invoiceQueue } from '../../jobs/invoice';
+import { paymentQueue } from '../../jobs/payment';
+import type { CallbackArgs } from '../../libs/auth';
+import { wallet } from '../../libs/auth';
+import { getClient } from '../../libs/chain/arcblock';
+import dayjs from '../../libs/dayjs';
+import { ensureInvoiceForCollect } from './shared';
+
+// Used to collect an open invoice failed to collect automatically
+// TODO: support multiple chain and multiple currency
+export default {
+  action: 'collect',
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { invoiceId } = extraParams;
+    const { invoice, paymentIntent, paymentCurrency, paymentMethod } = await ensureInvoiceForCollect(invoiceId);
+
+    const tokens = [{ address: paymentCurrency.contract as string, value: invoice.amount_due }];
+    // @ts-ignore
+    const itx: TransferV3Tx = {
+      outputs: [{ owner: wallet.address, tokens, assets: [] }],
+      data: {
+        type: 'json',
+        // @ts-ignore
+        value: {
+          appId: wallet.address,
+          paymentIntentId: paymentIntent.id,
+          invoiceId,
+        },
+      },
+    };
+
+    if (paymentMethod.type === 'arcblock') {
+      return {
+        prepareTx: {
+          type: 'TransferV3Tx',
+          description: `Pay for invoice ${invoice.number}`,
+          partialTx: { from: userDid, pk: userPk, itx },
+          requirement: { tokens },
+          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, claims, request, extraParams }: CallbackArgs) => {
+    const { invoiceId } = extraParams;
+    const { invoice, paymentIntent, paymentMethod } = await ensureInvoiceForCollect(invoiceId);
+
+    if (paymentMethod.type === 'arcblock') {
+      await paymentIntent.update({ status: 'processing' });
+      const client = getClient(paymentMethod.settings.arcblock?.api_host as string);
+      const claim = claims.find((x) => x.type === 'prepareTx');
+
+      const tx: Partial<Transaction> = client.decodeTx(claim.finalTx);
+      if (claim.delegator && claim.from) {
+        tx.delegator = claim.delegator;
+        tx.from = claim.from;
+      }
+
+      const txHash = await client.sendTransferV3Tx(
+        // @ts-ignore
+        { tx, wallet: fromAddress(userDid) },
+        { headers: client.pickGasPayerHeaders(request) }
+      );
+
+      await paymentIntent.update({
+        status: 'succeeded',
+        amount_received: invoice.amount_due,
+        capture_method: 'manual',
+        payment_details: {
+          tx_hash: txHash,
+          payer: userDid,
+        },
+      });
+
+      await invoice.update({
+        paid: true,
+        status: 'paid',
+        amount_due: '0',
+        amount_paid: invoice.amount_due,
+        amount_remaining: '0',
+        attempt_count: invoice.attempt_count + 1,
+        status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
+        collection_method: 'send_invoice',
+      });
+
+      // cleanup the queue
+      let exist = await paymentQueue.get(paymentIntent.id);
+      if (exist) {
+        await paymentQueue.cancel(paymentIntent.id);
+      }
+      exist = await invoiceQueue.get(invoice.id);
+      if (exist) {
+        await invoiceQueue.cancel(invoice.id);
+      }
+
+      return { hash: txHash };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};

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

@@ -0,0 +1,116 @@
+import type { Transaction, TransferV3Tx } from '@ocap/client';
+import { fromAddress } from '@ocap/wallet';
+
+import type { CallbackArgs } from '../../libs/auth';
+import { wallet } from '../../libs/auth';
+import { getClient } from '../../libs/chain/arcblock';
+import dayjs from '../../libs/dayjs';
+import { ensureInvoiceForCheckout, ensurePaymentIntent } from './shared';
+
+export default {
+  action: 'pay',
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { checkoutSessionId } = extraParams;
+    const { paymentIntent, paymentCurrency, paymentMethod } = await ensurePaymentIntent(checkoutSessionId, userDid);
+    if (!paymentIntent) {
+      throw new Error('Payment intent not found');
+    }
+
+    const tokens = [{ address: paymentCurrency.contract as string, value: paymentIntent.amount }];
+    // @ts-ignore
+    const itx: TransferV3Tx = {
+      outputs: [{ owner: wallet.address, tokens, assets: [] }],
+      data: {
+        type: 'json',
+        // @ts-ignore
+        value: {
+          appId: wallet.address,
+          paymentIntentId: paymentIntent.id,
+          checkoutSessionId,
+        },
+      },
+    };
+
+    // TODO: support multiple chain and multiple currency
+    if (paymentMethod.type === 'arcblock') {
+      return {
+        prepareTx: {
+          type: 'TransferV3Tx',
+          description: `Approve the transfer to complete checkout ${paymentIntent.id}`,
+          partialTx: { from: userDid, pk: userPk, itx },
+          requirement: { tokens },
+          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, claims, request, extraParams }: CallbackArgs) => {
+    const { checkoutSessionId } = extraParams;
+    const { checkoutSession, customer, paymentIntent, paymentMethod } = await ensurePaymentIntent(
+      checkoutSessionId,
+      userDid
+    );
+    if (!paymentIntent) {
+      throw new Error('Payment intent not found');
+    }
+
+    const { invoice } = await ensureInvoiceForCheckout({ checkoutSession, customer, paymentIntent });
+
+    if (paymentMethod.type === 'arcblock') {
+      await paymentIntent.update({ status: 'processing' });
+      const client = getClient(paymentMethod.settings.arcblock?.api_host as string);
+      const claim = claims.find((x) => x.type === 'prepareTx');
+
+      const tx: Partial<Transaction> = client.decodeTx(claim.finalTx);
+      if (claim.delegator && claim.from) {
+        tx.delegator = claim.delegator;
+        tx.from = claim.from;
+      }
+
+      const txHash = await client.sendTransferV3Tx(
+        // @ts-ignore
+        { tx, wallet: fromAddress(userDid) },
+        { headers: client.pickGasPayerHeaders(request) }
+      );
+
+      await checkoutSession.update({
+        status: 'complete',
+        payment_status: 'paid',
+        payment_details: {
+          tx_hash: txHash,
+          payer: userDid,
+        },
+      });
+      await paymentIntent.update({
+        status: 'succeeded',
+        amount_received: paymentIntent.amount,
+        payment_details: {
+          tx_hash: txHash,
+          payer: userDid,
+        },
+      });
+
+      if (invoice) {
+        await invoice.update({
+          paid: true,
+          status: 'paid',
+          amount_due: '0',
+          amount_paid: paymentIntent.amount,
+          amount_remaining: '0',
+          attempt_count: invoice.attempt_count + 1,
+          attempted: true,
+          status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
+        });
+      }
+
+      return { hash: txHash };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};

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

@@ -0,0 +1,121 @@
+import { toTypeInfo } from '@arcblock/did';
+import { toDelegateAddress } from '@arcblock/did-util';
+import type { Transaction } from '@ocap/client';
+import { fromPublicKey } from '@ocap/wallet';
+
+import { subscriptionQueue } from '../../jobs/subscription';
+import type { CallbackArgs } from '../../libs/auth';
+import { wallet } from '../../libs/auth';
+import { getClient } from '../../libs/chain/arcblock';
+import { ensureSetupIntent } from './shared';
+
+export default {
+  action: 'setup',
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { checkoutSessionId } = extraParams;
+    const { paymentMethod, subscription } = await ensureSetupIntent(checkoutSessionId, userDid);
+    if (!subscription) {
+      throw new Error('Subscription for checkoutSession not found');
+    }
+
+    // TODO: support multiple chain and multiple currency
+    if (paymentMethod.type === 'arcblock') {
+      return {
+        signature: {
+          type: 'DelegateTx',
+          description: `Sign the delegation to setup subscription ${subscription.id}`,
+          wallet: fromPublicKey(userPk, toTypeInfo(userDid)),
+          data: {
+            itx: {
+              address: toDelegateAddress(userDid, wallet.address),
+              to: wallet.address,
+              ops: [{ typeUrl: 'fg:t:transfer_v2', rules: [] }],
+              data: {
+                type: 'json',
+                // @ts-ignore
+                value: {
+                  appId: wallet.address,
+                  subscriptionId: subscription.id,
+                  checkoutSessionId,
+                },
+              },
+            },
+          },
+          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, request, extraParams }: CallbackArgs) => {
+    const { checkoutSessionId } = extraParams;
+    const { setupIntent, checkoutSession, paymentMethod, subscription } = await ensureSetupIntent(
+      checkoutSessionId,
+      userDid
+    );
+
+    if (!subscription) {
+      throw new Error('Subscription for checkoutSession not found');
+    }
+
+    if (paymentMethod.type === 'arcblock') {
+      await subscription.update({
+        payment_settings: {
+          payment_method_types: ['arcblock'],
+          payment_method_options: {
+            arcblock: { payer: userDid },
+          },
+        },
+      });
+
+      const client = getClient(paymentMethod.settings.arcblock?.api_host as string);
+      const claim = claims.find((x) => x.type === 'signature');
+
+      // execute the delegate tx
+      const tx: Partial<Transaction> = client.decodeTx(claim.origin);
+      const txHash = await client.sendDelegateTx(
+        // @ts-ignore
+        { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)), signature: claim.sig },
+        { headers: client.pickGasPayerHeaders(request) }
+      );
+
+      await setupIntent.update({
+        status: 'succeeded',
+        payment_method_types: ['arcblock'],
+        payment_method_options: {
+          arcblock: { payer: userDid },
+        },
+        setup_details: {
+          tx_hash: txHash,
+          payer: userDid,
+        },
+      });
+
+      await subscription.update({
+        status: subscription.trail_end ? 'trialing' : 'active',
+        payment_details: {
+          tx_hash: txHash,
+          payer: userDid,
+        },
+      });
+
+      await checkoutSession.update({ status: 'complete', payment_status: 'paid' });
+
+      // FIXME: for trialing subscriptions should we do this after 1st normal cycle
+      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`);
+  },
+};