payment-kit 1.17.12 → 1.18.1

package/api/src/integrations/arcblock/stake.ts

@@ -4,7 +4,6 @@ import assert from 'assert';
 
 import { isEthereumDid } from '@arcblock/did';
 import { toStakeAddress } from '@arcblock/did-util';
-import env from '@blocklet/sdk/lib/env';
 import { BN, fromUnitToToken, toBN } from '@ocap/util';
 
 import { Op } from 'sequelize';
@@ -26,10 +25,6 @@ export async function ensureStakedForGas() {
 
       try {
         const { state: account } = await client.getAccountState({ address: wallet.address });
-        if (!account) {
-          const hash = await client.declare({ moniker: env.appNameSlug, wallet });
-          logger.info(`declared app on chain ${host}`, { hash });
-        }
 
         const address = toStakeAddress(wallet.address, wallet.address);
         const { state: stake } = await client.getStakeState({ address });

package/api/src/libs/notification/template/customer-revenue-succeeded.ts

@@ -0,0 +1,254 @@
+/* eslint-disable @typescript-eslint/brace-style */
+/* eslint-disable @typescript-eslint/indent */
+import { fromUnitToToken } from '@ocap/util';
+import { getUrl } from '@blocklet/sdk';
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { translate } from '../../../locales';
+import { CheckoutSession, Customer, PaymentLink, PaymentMethod, Payout } from '../../../store/models';
+import { PaymentCurrency } from '../../../store/models/payment-currency';
+import { formatTime } from '../../time';
+import { getCustomerProfileUrl, getExplorerLink, getUserOrAppInfo } from '../../util';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+import { getCustomerPayoutPageUrl } from '../../payout';
+import { PaymentIntent } from '../../../store/models/payment-intent';
+
+export interface CustomerRevenueSucceededEmailTemplateOptions {
+  payoutId: string;
+}
+
+interface CustomerRevenueSucceededEmailTemplateContext {
+  locale: string;
+  at: string;
+  paymentIntentId: string;
+
+  chainHost: string | undefined;
+  userDid: string;
+  paymentInfo: string;
+  user: string;
+  revenueDetail: {
+    url: string;
+    title: string;
+    appDID: string;
+    logo?: string;
+    desc?: string;
+  };
+
+  viewPayoutLink: string;
+  viewTxHashLink: string;
+  type: 'payment' | 'donate';
+}
+
+/**
+ * @description
+ * @export
+ * @class CustomerRevenueSucceededEmailTemplate
+ * @implements {BaseEmailTemplate<CustomerRevenueSucceededEmailTemplateContext>}
+ */
+export class CustomerRevenueSucceededEmailTemplate
+  implements BaseEmailTemplate<CustomerRevenueSucceededEmailTemplateContext>
+{
+  options: CustomerRevenueSucceededEmailTemplateOptions;
+
+  constructor(options: CustomerRevenueSucceededEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  async getContext(): Promise<CustomerRevenueSucceededEmailTemplateContext> {
+    const payout = (await Payout.findByPk(this.options.payoutId, {
+      include: [
+        {
+          model: PaymentIntent,
+          as: 'paymentIntent',
+        },
+      ],
+    })) as Payout & { paymentIntent: PaymentIntent };
+    if (!payout) {
+      throw new Error(`Payout(${this.options.payoutId}) not found`);
+    }
+
+    if (!payout.paymentIntent) {
+      throw new Error(`PaymentIntent not found for payout: ${this.options.payoutId}`);
+    }
+
+    const customer = await Customer.findByPk(payout.customer_id);
+    if (!customer) {
+      throw new Error(`Customer not found: ${payout.customer_id}`);
+    }
+
+    const paymentCurrency = (await PaymentCurrency.findOne({
+      where: {
+        id: payout.currency_id,
+      },
+    })) as PaymentCurrency;
+
+    const userDid: string = customer.did;
+    const locale = await getUserLocale(userDid);
+    const at: string = formatTime(payout.created_at);
+    let type: 'payment' | 'donate' = 'payment';
+
+    try {
+      const checkoutSession = await CheckoutSession.findOne({
+        where: {
+          payment_intent_id: payout.payment_intent_id,
+        },
+        attributes: ['id', 'submit_type'],
+      });
+      if (checkoutSession && checkoutSession.submit_type === 'donate') {
+        type = 'donate';
+      }
+    } catch (error) {
+      console.error(error);
+    }
+
+    const payer = await Customer.findByPk(payout.paymentIntent?.customer_id);
+    if (!payer) {
+      throw new Error(`Payer not found for paymentIntent: ${payout.paymentIntent?.customer_id}`);
+    }
+
+    const paymentInfo: string = `${fromUnitToToken(payout.amount, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
+    const userInfo = await getUserOrAppInfo(payer.did);
+    const revenueDetail = {
+      url: getCustomerProfileUrl({ userDid: payer.did, locale }),
+      title: translate('notification.customerRevenueSucceeded.sended', locale, {
+        address: payer.name || payer.did,
+        amount: paymentInfo,
+      }),
+      logo: userInfo?.avatar || getUrl('/methods/default.png'),
+      appDID: payer.did,
+      desc: '',
+    };
+
+    const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(payout.payment_method_id);
+    // @ts-expect-error
+    const chainHost: string | undefined = paymentMethod?.settings?.[paymentMethod.type]?.api_host;
+    const viewPayoutLink = getCustomerPayoutPageUrl({
+      payoutId: this.options.payoutId,
+      userDid,
+      locale,
+    });
+
+    // @ts-expect-error
+    const txHash: string | undefined = payout?.payment_details?.[paymentMethod.type]?.tx_hash;
+    const viewTxHashLink: string =
+      (txHash &&
+        getExplorerLink({
+          type: 'tx',
+          did: txHash,
+          chainHost,
+        })) ||
+      '';
+
+    return {
+      locale,
+      at,
+      type,
+      user: payer.name || userInfo?.name || payer.did,
+      paymentIntentId: payout.payment_intent_id,
+      userDid,
+      chainHost,
+      paymentInfo,
+      revenueDetail,
+
+      viewPayoutLink,
+      viewTxHashLink,
+    };
+  }
+
+  async getReference(paymentIntentId: string): Promise<string> {
+    try {
+      const checkoutSession = (await CheckoutSession.findOne({
+        where: {
+          payment_intent_id: paymentIntentId,
+        },
+        attributes: ['id', 'payment_link_id'],
+      })) as CheckoutSession;
+      if (!checkoutSession) {
+        throw new Error(`CheckoutSession not found for paymentIntentId: ${paymentIntentId}`);
+      }
+      if (!checkoutSession.payment_link_id) {
+        throw new Error(`Payment link cannot be found for checkoutSession: ${checkoutSession.id}`);
+      }
+      const paymentLink = await PaymentLink.findByPk(checkoutSession.payment_link_id);
+      if (!paymentLink) {
+        throw new Error(`Payment link cannot be found for payment_link_id(${checkoutSession.payment_link_id})`);
+      }
+      return paymentLink.donation_settings?.reference || '';
+    } catch (error) {
+      console.error(error);
+      return '';
+    }
+  }
+
+  async getTemplate(): Promise<BaseEmailTemplateType> {
+    const {
+      locale,
+      at,
+      user,
+      type,
+      paymentIntentId,
+      paymentInfo,
+      revenueDetail,
+
+      viewPayoutLink,
+      viewTxHashLink,
+    } = await this.getContext();
+
+    const reference = await this.getReference(paymentIntentId);
+
+    const template: BaseEmailTemplateType = {
+      title: translate(`notification.customerRevenueSucceeded.${type}.title`, locale),
+      body: translate(`notification.customerRevenueSucceeded.${type}.body`, locale, {
+        at,
+        amount: paymentInfo,
+        user,
+      }),
+      // @ts-expect-error
+      attachments: [
+        {
+          type: 'section',
+          fields: [
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.customerRevenueSucceeded.sender', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: ' ',
+              },
+            },
+          ].filter(Boolean),
+        },
+        {
+          type: 'dapp',
+          data: revenueDetail,
+        },
+      ].filter(Boolean),
+      // @ts-expect-error
+      actions: [
+        viewPayoutLink && {
+          name: translate('notification.customerRevenueSucceeded.viewDetail', locale),
+          title: translate('notification.customerRevenueSucceeded.viewDetail', locale),
+          link: viewPayoutLink,
+        },
+        viewTxHashLink && {
+          name: translate('notification.common.viewTxHash', locale),
+          title: translate('notification.common.viewTxHash', locale),
+          link: viewTxHashLink,
+        },
+        reference && {
+          name: translate('notification.customerRevenueSucceeded.donate.tipDetail', locale),
+          title: translate('notification.customerRevenueSucceeded.donate.tipDetail', locale),
+          link: reference,
+        },
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}

package/api/src/libs/notification/template/customer-reward-succeeded.ts

@@ -5,7 +5,7 @@ import isEmpty from 'lodash/isEmpty';
 import pWaitFor from 'p-wait-for';
 import type { LiteralUnion } from 'type-fest';
 
-import { joinURL } from 'ufo';
+import { getUrl } from '@blocklet/sdk';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
 import {
@@ -22,9 +22,8 @@ import { PaymentCurrency } from '../../../store/models/payment-currency';
 import { getCustomerInvoicePageUrl } from '../../invoice';
 import logger from '../../logger';
 import { formatTime } from '../../time';
-import { getCustomerProfileUrl, getExplorerLink } from '../../util';
+import { getBlockletJson, getCustomerProfileUrl, getExplorerLink, getUserOrAppInfo } from '../../util';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
-import { blocklet } from '../../auth';
 
 export interface CustomerRewardSucceededEmailTemplateOptions {
   checkoutSessionId: string;
@@ -197,8 +196,9 @@ export class CustomerRewardSucceededEmailTemplate
       return null;
     }
 
+    const blockletJson = await getBlockletJson();
     const promises = paymentIntent.beneficiaries!.map((x: PaymentBeneficiary) => {
-      return blocklet.getUser(x.address);
+      return getUserOrAppInfo(x.address, blockletJson);
     });
     const users = await Promise.all(promises);
     if (!users.length) {
@@ -207,15 +207,12 @@ export class CustomerRewardSucceededEmailTemplate
     }
     const rewardDetail = paymentIntent.beneficiaries!.map((x: PaymentBeneficiary, index: number) => {
       return {
-        url: getCustomerProfileUrl({ userDid: x.address, locale }),
+        url: users[index]?.url || getCustomerProfileUrl({ userDid: x.address, locale }),
         title: translate('notification.customerRewardSucceeded.received', locale, {
-          address: users[index]?.user?.fullName || x.address,
+          address: users[index]?.name || x.address,
           amount: `${fromUnitToToken(x.share, paymentCurrency.decimal)} ${paymentCurrency.symbol}`,
         }),
-        logo:
-          process.env.BLOCKLET_APP_URL && users[index]?.user?.avatar
-            ? joinURL(process.env.BLOCKLET_APP_URL, users[index]?.user?.avatar as string)
-            : '',
+        logo: users[index]?.avatar ? users[index]?.avatar : getUrl('/methods/default.png'),
         appDID: x.address,
         desc: '',
       };
@@ -246,7 +243,6 @@ export class CustomerRewardSucceededEmailTemplate
       body: `${translate('notification.customerRewardSucceeded.body', locale, {
         at,
         amount: paymentInfo,
-        subject: `<${donationSettings.title}(link:${donationSettings.reference})>`,
       })}`,
       // @ts-expect-error
       attachments: [
@@ -327,6 +323,11 @@ export class CustomerRewardSucceededEmailTemplate
           title: translate('notification.common.viewTxHash', locale),
           link: viewTxHashLink,
         },
+        donationSettings.reference && {
+          name: translate('notification.customerRewardSucceeded.viewDetail', locale),
+          title: translate('notification.customerRewardSucceeded.viewDetail', locale),
+          link: donationSettings.reference,
+        },
       ].filter(Boolean),
     };
 

package/api/src/libs/payment.ts

@@ -10,11 +10,19 @@ import cloneDeep from 'lodash/cloneDeep';
 import type { LiteralUnion } from 'type-fest';
 
 import { fetchErc20Allowance, fetchErc20Balance, fetchEtherBalance } from '../integrations/ethereum/token';
-import { Invoice, PaymentCurrency, PaymentIntent, PaymentMethod, TCustomer, TLineItemExpanded } from '../store/models';
+import {
+  Invoice,
+  PaymentCurrency,
+  PaymentIntent,
+  PaymentLink,
+  PaymentMethod,
+  TCustomer,
+  TLineItemExpanded,
+} from '../store/models';
 import type { TPaymentCurrency } from '../store/models/payment-currency';
 import { blocklet, ethWallet, wallet } from './auth';
 import logger from './logger';
-import { OCAP_PAYMENT_TX_TYPE } from './util';
+import { getBlockletJson, getUserOrAppInfo, OCAP_PAYMENT_TX_TYPE } from './util';
 import { CHARGE_SUPPORTED_CHAIN_TYPES, EVM_CHAIN_TYPES } from './constants';
 
 export interface SufficientForPaymentResult {
@@ -345,3 +353,40 @@ export async function isBalanceSufficientForRefund(args: {
 
   throw new Error(`isBalanceSufficientForRefund: Payment method ${paymentMethod.type} not supported`);
 }
+
+export async function getDonationBenefits(paymentLink: PaymentLink, url?: string) {
+  const { donation_settings: donationSettings } = paymentLink;
+  if (!donationSettings) {
+    return [];
+  }
+  const { beneficiaries } = donationSettings;
+  const total = beneficiaries.reduce((t, x) => t + Number(x.share), 0);
+  if (total === 0) {
+    return beneficiaries;
+  }
+  const blockletJson = await getBlockletJson(url);
+  const result = await Promise.all(
+    beneficiaries.map(async (beneficiary) => {
+      const { address, share, name, avatar } = beneficiary;
+      try {
+        const info = await getUserOrAppInfo(address, blockletJson);
+        return {
+          address,
+          percent: (Number(share) * 100) / total,
+          name: name || info?.name || '',
+          avatar: avatar || info?.avatar || '',
+          url: info?.url || '',
+          type: info?.type || 'user',
+        };
+      } catch (error) {
+        return {
+          address,
+          percent: (Number(share) * 100) / total,
+          name: name || '',
+          avatar: avatar || '',
+        };
+      }
+    })
+  );
+  return result;
+}

package/api/src/libs/payout.ts

@@ -0,0 +1,24 @@
+import { component } from '@blocklet/sdk';
+import type { LiteralUnion } from 'type-fest';
+import { withQuery } from 'ufo';
+import { getConnectQueryParam } from './util';
+
+export function getCustomerPayoutPageUrl({
+  payoutId,
+  userDid,
+  locale = 'en',
+  action = '',
+}: {
+  payoutId: string;
+  userDid: string;
+  locale: LiteralUnion<'en' | 'zh', string>;
+  action?: LiteralUnion<'pay', string>;
+}) {
+  return component.getUrl(
+    withQuery(`customer/payout/${payoutId}`, {
+      locale,
+      action,
+      ...getConnectQueryParam({ userDid }),
+    })
+  );
+}

package/api/src/libs/util.ts

@@ -6,8 +6,9 @@ import { getWalletDid } from '@blocklet/sdk/lib/did';
 import { toStakeAddress } from '@arcblock/did-util';
 import { customAlphabet } from 'nanoid';
 import type { LiteralUnion } from 'type-fest';
-import { joinURL, withQuery } from 'ufo';
+import { joinURL, withQuery, withTrailingSlash } from 'ufo';
 
+import axios from 'axios';
 import dayjs from './dayjs';
 import { blocklet, wallet } from './auth';
 import type { Subscription } from '../store/models';
@@ -72,6 +73,10 @@ export const STRIPE_EVENTS: any[] = [
   'refund.updated',
 ];
 
+const api = axios.create({
+  timeout: 10 * 1000,
+});
+
 export function md5(input: string) {
   return crypto.createHash('md5').update(input).digest('hex');
 }
@@ -177,6 +182,83 @@ export function getDataObjectFromQuery(
   return result;
 }
 
+export function safeJsonParse(input: any, defaultValue: any) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    if (defaultValue === undefined) {
+      return input;
+    }
+    return defaultValue;
+  }
+}
+
+const cachedBlockletJsonResult = new Map<string, { data: any; expiry: number }>();
+const CACHE_TTL = 60 * 60 * 1000; // 1 hour
+
+export async function getBlockletJson(url?: string) {
+  const blockletKey = url || process.env.BLOCKLET_APP_URL || 'default';
+  const now = Date.now();
+
+  if (cachedBlockletJsonResult.has(blockletKey)) {
+    const cached = cachedBlockletJsonResult.get(blockletKey);
+    if (cached && now < cached.expiry) {
+      return cached.data;
+    }
+  }
+  const scriptUrl = new URL('__blocklet__.js?type=json', withTrailingSlash(url || process.env.BLOCKLET_APP_URL));
+  try {
+    const { data: blockletMeta } = await api.get(scriptUrl.href);
+    cachedBlockletJsonResult.set(blockletKey, { data: blockletMeta, expiry: now + CACHE_TTL });
+    return blockletMeta;
+  } catch (err) {
+    logger.error(`getBlockletJson error for ${scriptUrl}`, err);
+    if (process.env.BLOCKLET_MOUNT_POINTS) {
+      const BLOCKLET_MOUNT_POINTS = safeJsonParse(process.env.BLOCKLET_MOUNT_POINTS, []);
+      return {
+        componentMountPoints: BLOCKLET_MOUNT_POINTS,
+        appId: process.env.BLOCKLET_APP_ID,
+        appName: process.env.BLOCKLET_APP_NAME,
+        appLogo: joinURL(process.env.BLOCKLET_APP_URL!, '.well-known/service/blocklet/logo'),
+        appUrl: process.env.BLOCKLET_APP_URL,
+      };
+    }
+    return null;
+  }
+}
+
+export async function getUserOrAppInfo(
+  address: string,
+  blockletJson?: any
+): Promise<{ name: string; avatar: string; type: 'dapp' | 'user'; url: string } | null> {
+  if (blockletJson) {
+    if (blockletJson?.appId === address) {
+      return {
+        name: blockletJson?.appName,
+        avatar: blockletJson?.appLogo,
+        type: 'dapp',
+        url: blockletJson?.appUrl,
+      };
+    }
+    const appInfo = blockletJson?.componentMountPoints?.find((x: any) => x.appId === address);
+    if (appInfo) {
+      return {
+        name: appInfo.name,
+        avatar: joinURL(process.env.BLOCKLET_APP_URL!, `.well-known/service/blocklet/logo-bundle/${appInfo.did}`),
+        type: 'dapp',
+        url: joinURL(process.env.BLOCKLET_APP_URL!, appInfo.mountPoint),
+      };
+    }
+  }
+  const { user } = await blocklet.getUser(address);
+  return {
+    name: user?.fullName,
+    avatar: joinURL(process.env.BLOCKLET_APP_URL!, user?.avatar),
+    type: 'user',
+    url: getCustomerProfileUrl({ userDid: address, locale: 'en' }),
+  };
+}
+
 // @FIXME: 这个应该封装在某个通用类库里面 @jianchao @wangshijun
 export function getExplorerLink({
   type,

package/api/src/locales/en.ts

@@ -156,10 +156,25 @@ export default flat({
 
     customerRewardSucceeded: {
       title: 'Thanks for your reward of {amount}',
-      body: 'Thanks for your reward on {at} for {subject}, the amount of reward is {amount}. Your support is our driving force, thanks for your generous support!',
+      body: 'Thanks for your reward on {at}, the amount of reward is {amount}. Your support is our driving force, thanks for your generous support!',
       received: '{address} has received {amount}',
+      viewDetail: 'View Reference',
     },
 
+    customerRevenueSucceeded: {
+      donate: {
+        title: 'You received a tip',
+        body: 'Congratulations! On {at}, you received a tip of {amount} from {user}.',
+        tipDetail: 'View Tip Reference',
+      },
+      payment: {
+        title: 'You received a payment',
+        body: 'Congratulations! On {at}, you received a payment of {amount} from {user}.',
+      },
+      sender: 'Payer',
+      viewDetail: 'View Details',
+      sended: '{address} has sent {amount}',
+    },
     subscriptWillCanceled: {
       title: '{productName} subscription is about to be cancelled ',
       pastDue:

package/api/src/locales/zh.ts

@@ -93,7 +93,7 @@ export default flat({
     },
 
     oneTimePaymentSucceeded: {
-      title: '恭喜！您已购买 {productName} 成功',
+      title: '恭喜！您已成功购买 {productName}',
       body: '感谢您于 {at} 成功购买了 {productName}。我们将竭诚为您提供优质的服务，祝您使用愉快！',
     },
 
@@ -122,16 +122,16 @@ export default flat({
       title: '{productName} 扣费失败',
       body: '很抱歉地通知您，您的 {productName} 于 {at} 扣费失败。如有任何疑问，请及时联系我们。谢谢！',
       reason: {
-        noDidWallet: '您尚未绑定 DID Wallet，请绑定 DID Wallet，确保余额充足',
-        noDelegation: '您的 DID Wallet 尚未授权，请更新授权',
-        noTransferPermission: '您的 DID Wallet 未授予应用转账权限，请更新授权',
-        noTokenPermission: '您的 DID Wallet 未授予应用对应通证的转账权限，请更新授权',
-        noTransferTo: '您的 DID Wallet 未授予应用扣费权限，请更新授权',
-        noEnoughAllowance: '扣款金额超出单笔转账限额，请更新授权',
-        noToken: '您的账户没有任何代币，请充值代币',
-        noEnoughToken: '您的账户代币余额为 {balance}，不足 {price}，请充值代币',
-        noSupported: '不支持使用代币扣费，请检查您的套餐',
-        txSendFailed: '扣费交易发送失败',
+        noDidWallet: '您尚未绑定 DID Wallet，请绑定 DID Wallet，确保余额充足。',
+        noDelegation: '您的 DID Wallet 尚未授权，请更新授权。',
+        noTransferPermission: '您的 DID Wallet 未授予应用转账权限，请更新授权。',
+        noTokenPermission: '您的 DID Wallet 未授予应用对应通证的转账权限，请更新授权。',
+        noTransferTo: '您的 DID Wallet 未授予应用扣费权限，请更新授权。',
+        noEnoughAllowance: '扣款金额超出单笔转账限额，请更新授权。',
+        noToken: '您的账户没有任何代币，请充值代币。',
+        noEnoughToken: '您的账户代币余额为 {balance}，不足 {price}，请充值代币。',
+        noSupported: '不支持使用代币扣费，请检查您的套餐。',
+        txSendFailed: '扣费交易发送失败。',
       },
     },
 
@@ -152,8 +152,24 @@ export default flat({
 
     customerRewardSucceeded: {
       title: '感谢您打赏的 {amount}',
-      body: '感谢您于 {at} 在 {subject} 下的打赏，打赏金额为 {amount}。您的支持是我们前行的动力，谢谢您的大力支持！',
+      body: '感谢您于 {at} 的打赏，打赏金额为 {amount}。您的支持是我们前行的动力，谢谢您的大力支持！',
       received: '{address} 收到了 {amount}',
+      viewDetail: '查看详情',
+    },
+
+    customerRevenueSucceeded: {
+      donate: {
+        title: '您收到了一笔打赏',
+        body: '恭喜您于 {at} 收到了一笔来自 {user} 的打赏，打赏金额为 {amount}。',
+        tipDetail: '查看打赏原文',
+      },
+      payment: {
+        title: '您收到了一笔付款',
+        body: '恭喜您于 {at} 收到一笔来自 {user} 的 {amount}。',
+      },
+      sender: '付款方',
+      viewDetail: '查看详情',
+      sended: '{address} 付款给您 {amount}',
     },
 
     subscriptWillCanceled: {

package/api/src/queues/notification.ts

@@ -56,7 +56,7 @@ import {
   SubscriptionStakeSlashSucceededEmailTemplateOptions,
 } from '../libs/notification/template/subscription-stake-slash-succeeded';
 import createQueue from '../libs/queue';
-import { CheckoutSession, EventType, Invoice, PaymentLink, Refund, Subscription } from '../store/models';
+import { CheckoutSession, EventType, Invoice, PaymentLink, Payout, Refund, Subscription } from '../store/models';
 import {
   UsageReportEmptyEmailTemplate,
   UsageReportEmptyEmailTemplateOptions,
@@ -69,6 +69,10 @@ import {
   OverdraftProtectionExhaustedEmailTemplate,
   OverdraftProtectionExhaustedEmailTemplateOptions,
 } from '../libs/notification/template/subscription-overdraft-protection-exhausted';
+import {
+  CustomerRevenueSucceededEmailTemplate,
+  CustomerRevenueSucceededEmailTemplateOptions,
+} from '../libs/notification/template/customer-revenue-succeeded';
 
 export type NotificationQueueJobOptions = any;
 
@@ -141,6 +145,10 @@ function getNotificationTemplate(job: NotificationQueueJob): BaseEmailTemplate {
     );
   }
 
+  if (job.type === 'payout.paid') {
+    return new CustomerRevenueSucceededEmailTemplate(job.options as CustomerRevenueSucceededEmailTemplateOptions);
+  }
+
   throw new Error(`Unknown job type: ${job.type}`);
 }
 
@@ -339,4 +347,18 @@ export async function startNotificationQueue() {
       },
     });
   });
+
+  events.on('payout.paid', (payout: Payout) => {
+    if (payout.customer_id) {
+      notificationQueue.push({
+        id: `payout.paid.${payout.id}`,
+        job: {
+          type: 'payout.paid',
+          options: {
+            payoutId: payout.id,
+          },
+        },
+      });
+    }
+  });
 }