payment-kit 1.13.26 → 1.13.27

package/api/src/index.ts

@@ -9,7 +9,9 @@ import dotenv from 'dotenv-flow';
 import express, { ErrorRequestHandler, Request, Response } from 'express';
 import morgan from 'morgan';
 
+import { ensureStakedForGas } from './integrations/blockchain/stake';
 import { ensureWebhookRegistered } from './integrations/stripe/setup';
+import { startCheckoutSessionQueue } from './jobs/checkout-session';
 import { startEventQueue } from './jobs/event';
 import { startInvoiceQueue } from './jobs/invoice';
 import { startPaymentQueue } from './jobs/payment';
@@ -98,6 +100,11 @@ export const server = app.listen(port, (err?: any) => {
   startInvoiceQueue().then(() => logger.info('invoice queue started'));
   startSubscriptionQueue().then(() => logger.info('subscription queue started'));
   startEventQueue().then(() => logger.info('event queue started'));
+  startCheckoutSessionQueue().then(() => logger.info('checkoutSession queue started'));
 
-  ensureWebhookRegistered().catch(console.error);
+  if (process.env.BLOCKLET_MODE === 'production') {
+    ensureWebhookRegistered().catch(console.error);
+  }
+
+  ensureStakedForGas().catch(console.error);
 });

package/api/src/integrations/blockchain/nft.ts

@@ -0,0 +1,125 @@
+// import pick from 'lodash/pick';
+import { formatFactoryState, preMintFromFactory } from '@ocap/asset';
+import merge from 'lodash/merge';
+
+import { wallet } from '../../libs/auth';
+import logger from '../../libs/logger';
+import { CheckoutSession, PaymentCurrency, PaymentIntent, PaymentMethod, Subscription } from '../../store/models';
+import { sendNftNotification } from '../blocklet/notification';
+
+export async function mintNftForCheckoutSession(id: string) {
+  const checkoutSession = await CheckoutSession.findByPk(id);
+  if (!checkoutSession) {
+    logger.warn('checkoutSession not found when attempt to mint nft', { id });
+    return;
+  }
+
+  if (checkoutSession.status !== 'complete') {
+    logger.warn('checkoutSession not completed when attempt to mint nft', { id });
+    return;
+  }
+
+  if (checkoutSession.nft_mint_status === 'disabled') {
+    logger.warn('nft mint not enabled for checkoutSession', { id, settings: checkoutSession.nft_mint_settings });
+    return;
+  }
+
+  if (checkoutSession.nft_mint_status === 'minted') {
+    logger.warn('checkoutSession nft already minted', { id, details: checkoutSession.nft_mint_details });
+    return;
+  }
+
+  if (checkoutSession.nft_mint_status === 'error') {
+    logger.warn('checkoutSession nft already error', { id, details: checkoutSession.nft_mint_details });
+    return;
+  }
+
+  // TODO: we may need retry here when the chain is temporarily inaccessible
+  const currency = await PaymentCurrency.findByPk(checkoutSession.currency_id);
+  const method = await PaymentMethod.findByPk(currency?.payment_method_id);
+  if (method?.type === 'arcblock') {
+    const client = method.getOcapClient();
+    const nftOwner = checkoutSession.customer_did;
+    const { factory, inputs } = checkoutSession.nft_mint_settings as any;
+
+    const [{ state: factoryState }, { state: appState }] = await Promise.all([
+      client.getFactoryState({ address: factory }),
+      client.getAccountState({ address: wallet.address }),
+    ]);
+
+    const preMint = preMintFromFactory({
+      factory: formatFactoryState(factoryState),
+      inputs: inputs || {},
+      owner: nftOwner,
+      issuer: { wallet, name: appState.moniker },
+    });
+    logger.info('nft preMint for checkoutSession', { id, inputs, nftOwner, factory, preMint });
+
+    const { state: nftState } = await client.getAccountState({ address: preMint.address });
+    if (nftState) {
+      await checkoutSession.update({
+        nft_mint_status: 'error',
+        nft_mint_details: {
+          arcblock: {
+            address: preMint.address,
+            owner: nftOwner as string,
+            error: 'NFT with same address already exist',
+          },
+        },
+      });
+      logger.warn('nft mint duplicate for checkoutSession', { id, details: checkoutSession.nft_mint_details });
+      return;
+    }
+
+    const hash = await client.sendMintAssetTx({
+      tx: {
+        itx: {
+          factory,
+          address: preMint.address,
+          assets: [],
+          variables: Object.entries(preMint.variables).map(([key, value]) => ({ name: key, value })),
+          owner: nftOwner,
+        },
+      },
+      wallet,
+    });
+
+    logger.info('nft minted for checkoutSession', { id, inputs, nftOwner, factory, hash });
+    await checkoutSession.update({
+      nft_mint_status: 'minted',
+      nft_mint_details: {
+        arcblock: {
+          tx_hash: hash,
+          address: preMint.address,
+          owner: nftOwner as string,
+        },
+      },
+    });
+
+    if (checkoutSession.subscription_id) {
+      const subscription = await Subscription.findByPk(checkoutSession.subscription_id);
+      if (subscription && subscription.metadata?.nft_address) {
+        await subscription.update({ metadata: merge(subscription.metadata || {}, { nft_address: preMint.address }) });
+      }
+    }
+    if (checkoutSession.payment_intent_id) {
+      const paymentIntent = await PaymentIntent.findByPk(checkoutSession.payment_intent_id);
+      if (paymentIntent && paymentIntent.metadata?.nft_address) {
+        await paymentIntent.update({ metadata: merge(paymentIntent.metadata || {}, { nft_address: preMint.address }) });
+      }
+    }
+
+    await sendNftNotification(
+      preMint.address,
+      nftOwner as string,
+      method.settings.arcblock?.api_host as string,
+      factoryState.name
+    );
+    logger.info('nft sent for checkoutSession', { id, nftOwner });
+    await checkoutSession.update({ nft_mint_status: 'sent' });
+
+    return;
+  }
+
+  logger.warn('nft mint not supported for payment method', { id, type: method?.type });
+}

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

@@ -0,0 +1,55 @@
+/* eslint-disable no-continue */
+/* eslint-disable no-await-in-loop */
+import { toStakeAddress } from '@arcblock/did-util';
+import env from '@blocklet/sdk/lib/env';
+import { fromUnitToToken, toBN } from '@ocap/util';
+
+import { wallet } from '../../libs/auth';
+import logger from '../../libs/logger';
+import { PaymentCurrency, PaymentMethod } from '../../store/models';
+
+export async function ensureStakedForGas() {
+  const currencies = await PaymentCurrency.findAll({ where: { active: true, is_base_currency: true } });
+
+  for (const currency of currencies) {
+    const method = await PaymentMethod.findByPk(currency.payment_method_id);
+    if (method && method.type === 'arcblock') {
+      const client = method.getOcapClient();
+      const host = method.settings.arcblock?.api_host;
+
+      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 });
+        if (stake) {
+          logger.info(`app already staked for gas on chain ${host}`);
+          continue;
+        }
+
+        const result = await client.getForgeState({});
+        const { token, txConfig } = result.state;
+        const holding = account.tokens.find((x: any) => x.address === token.address);
+        if (toBN(holding?.value || '0').lte(toBN(txConfig.txGas.minStake))) {
+          logger.info(`not enough balance to stake for gas on chain ${host}`);
+          continue;
+        }
+
+        // @ts-ignore
+        const [hash] = await client.stake({
+          to: wallet.address,
+          message: 'stake-for-gas',
+          tokens: [{ address: token.address, value: fromUnitToToken(txConfig.txGas.minStake, token.decimal) }],
+          wallet,
+        });
+        logger.info(`staked for gas on chain ${host}`, { hash });
+      } catch (err) {
+        logger.error(`stake for gas on chain ${host} failed`, err);
+      }
+    }
+  }
+}

package/api/src/integrations/blocklet/notification.ts

@@ -0,0 +1,101 @@
+import Notification from '@blocklet/sdk/service/notification';
+import { toDid } from '@ocap/util';
+
+import { blocklet } from '../../libs/auth';
+import logger from '../../libs/logger';
+import { translate } from '../../locales';
+
+export async function getUserLocale(userDid: string) {
+  const { user } = await blocklet.getUser(userDid);
+  return user?.locale || 'en';
+}
+
+export function createInfoRows(info: any = {}) {
+  const fields = Object.keys(info).reduce((list, cur) => {
+    const item = info[cur];
+    const data = {
+      type: 'plain',
+      text: item,
+      color: undefined,
+    };
+
+    if (Array.isArray(item)) {
+      const [text, color] = item;
+      data.text = text;
+      if (color) {
+        data.color = color;
+      }
+    }
+
+    if (typeof data.text !== 'string') {
+      data.text = String(data.text);
+    }
+
+    list.push(
+      // @ts-ignore
+      {
+        type: 'text',
+        data: {
+          type: 'plain',
+          color: '#9397A1',
+          text: cur,
+        },
+      },
+      {
+        type: 'text',
+        data,
+      }
+    );
+    return list;
+  }, []);
+
+  return {
+    type: 'section',
+    fields,
+  };
+}
+
+export async function sendNotification({
+  to,
+  title,
+  message,
+  actions,
+  attachments = [],
+}: {
+  to: string;
+  title: string;
+  message: string;
+  actions: any[];
+  attachments: any[];
+}) {
+  try {
+    const payload = { title, body: message, actions: actions || [], attachments: [...attachments] };
+    await Notification.sendToUser(to, payload);
+    logger.info('text message was sent', { to, payload: JSON.stringify(payload, null, 2) });
+  } catch (error) {
+    logger.error('send text message failed', { error, to, message, actions, attachments });
+    throw error;
+  }
+}
+
+export async function sendNftNotification(nftDid: string, userDid: string, chainHost: string, collection: string) {
+  const locale = await getUserLocale(userDid);
+  await sendNotification({
+    to: userDid,
+    title: translate('notification.mintNFT.title', locale, { collection }),
+    message: translate('notification.mintNFT.message', locale, { collection }),
+    attachments: [
+      {
+        type: 'asset',
+        data: {
+          chainHost,
+          did: nftDid,
+        },
+      },
+      createInfoRows({
+        [translate('notification.sendTo', locale)]: toDid(userDid),
+      }),
+    ],
+    actions: [],
+  });
+}

package/api/src/integrations/blocklet/passport.ts

@@ -0,0 +1,139 @@
+import merge from 'lodash/merge';
+import pick from 'lodash/pick';
+
+import { blocklet } from '../../libs/auth';
+import logger from '../../libs/logger';
+import {
+  CheckoutSession,
+  PaymentLink,
+  Price,
+  PricingTable,
+  Product,
+  Subscription,
+  TLineItemExpanded,
+} from '../../store/models';
+
+export async function checkPassportForPaymentLink(doc: PaymentLink) {
+  // @ts-ignore
+  const items: TLineItemExpanded[] = await Price.expand(doc.line_items, true);
+  const item = items.find((x) => x.price.product?.metadata?.passport);
+  return item?.price.product?.metadata?.passport;
+}
+
+export async function checkPassportForPricingTable(doc: PricingTable) {
+  const products = await Product.findAll({ where: { id: doc?.items.map((x) => x.product_id) } });
+  const product = products.find((x) => x.metadata?.passport);
+  return product?.metadata?.passport;
+}
+
+export async function ensurePassportIssued(checkoutSession: CheckoutSession) {
+  if (checkoutSession.status !== 'complete') {
+    logger.warn('checkoutSession not complete', pick(checkoutSession, ['id', 'status']));
+    return;
+  }
+  const info = pick(checkoutSession, ['id', 'metadata']);
+  if (!checkoutSession.customer_did) {
+    logger.warn('checkoutSession have no customer did', info);
+    return;
+  }
+  if (!checkoutSession.metadata?.passport) {
+    logger.warn('checkoutSession not contain any passport issue info', info);
+    return;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const { passport, pricing_table_id } = checkoutSession.metadata as any;
+  const { role } = await blocklet.getRole(passport);
+  if (!role) {
+    logger.warn('role not found for passport issuance', info);
+    return;
+  }
+
+  if (!role.extra?.acquire?.pay || !role.extra?.payment?.product) {
+    logger.warn('role config not valid for passport issuance', { ...info, role });
+    return;
+  }
+
+  const productId = role.extra.payment.product;
+
+  // pre issuance check
+  if (pricing_table_id) {
+    if (role.extra?.acquire?.pay !== pricing_table_id) {
+      logger.warn('source pricing table not match wth role config', merge(info, { role }));
+      return;
+    }
+
+    const doc = await PricingTable.findByPk(pricing_table_id);
+    if (!doc) {
+      logger.warn('source pricing table not found for passport issuance', info);
+      return;
+    }
+
+    if (doc.items.some((x) => x.product_id === productId) === false) {
+      logger.warn('source pricing table not contain product for passport issuance', { ...info, productId });
+      return;
+    }
+  } else if (checkoutSession.payment_link_id) {
+    if (role.extra?.acquire?.pay !== checkoutSession.payment_link_id) {
+      logger.warn('source payment link not match wth role config', merge(info, { role }));
+      return;
+    }
+
+    const doc = await PaymentLink.findByPk(checkoutSession.payment_link_id);
+    if (!doc) {
+      logger.warn('source payment link not found for passport issuance', info);
+      return;
+    }
+
+    const items = await Price.expand(doc.line_items);
+    if (items.some((x) => x.price.product_id === productId) === false) {
+      logger.warn('source payment link not contain product for passport issuance', { ...info, productId });
+      return;
+    }
+  } else {
+    logger.warn('no payment link or pricing table for passport issuance', info);
+  }
+
+  // do the issuance
+  await blocklet.issuePassportToUser({ userDid: checkoutSession.customer_did, role: passport });
+  logger.info(
+    'passport issued to user on checkout session complete',
+    merge(info, { role, customer: checkoutSession.customer_did })
+  );
+}
+
+export async function ensurePassportRevoked(subscription: Subscription) {
+  const info = pick(subscription, ['id', 'status']);
+  if (subscription.status !== 'canceled') {
+    logger.warn('subscription not canceled', info);
+    return;
+  }
+
+  const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
+  if (!checkoutSession) {
+    logger.warn('checkoutSession for subscription not found', info);
+    return;
+  }
+
+  if (!checkoutSession.metadata?.passport) {
+    logger.warn('checkoutSession not contain any passport issue info', info);
+    return;
+  }
+
+  const { user } = await blocklet.getUser(checkoutSession.customer_did as string, { enableConnectedAccount: true });
+  if (!user) {
+    logger.warn(
+      'user not found when revoke on subscription cancel',
+      merge(info, { did: checkoutSession.customer_did })
+    );
+    return;
+  }
+
+  const { passport } = checkoutSession.metadata as any;
+  const passports = user.passports.filter((x: any) => x.role === passport && x.status === 'valid');
+  await Promise.all(passports.map((x: any) => blocklet.revokeUserPassport({ userDid: user.did, passportId: x.id })));
+  logger.warn(
+    'user passports revoked on subscription cancel',
+    merge(info, { did: checkoutSession.customer_did, passports })
+  );
+}

package/api/src/integrations/stripe/handlers/invoice.ts

@@ -211,7 +211,7 @@ export async function handleInvoiceEvent(event: TEventExpanded, client: Stripe)
       if (subscription) {
         const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
         if (method && method.type === 'stripe') {
-          const tmp = await ensureStripeInvoice(event.data.object, subscription, method.getStripe());
+          const tmp = await ensureStripeInvoice(event.data.object, subscription, method.getStripeClient());
           localInvoiceId = tmp.id;
         }
       }

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

@@ -16,7 +16,7 @@ import {
 } from '../../store/models';
 
 export async function ensureStripeProduct(internal: Product, method: PaymentMethod) {
-  const client = method.getStripe();
+  const client = method.getStripeClient();
   const result = await client.products.search({ query: `metadata['id']:'${internal.id}'` });
   if (result.data.length > 0) {
     return result.data[0] as any;
@@ -45,7 +45,7 @@ export async function ensureStripeProduct(internal: Product, method: PaymentMeth
 }
 
 export async function ensureStripePrice(internal: Price, method: PaymentMethod, currency: PaymentCurrency) {
-  const client = method.getStripe();
+  const client = method.getStripeClient();
   const result = await client.prices.search({ query: `metadata['id']:'${internal.id}'` });
   if (result.data.length > 0) {
     return result.data[0] as any;
@@ -107,7 +107,7 @@ export async function ensureStripePrice(internal: Price, method: PaymentMethod,
 }
 
 export async function ensureStripeCustomer(internal: Customer, method: PaymentMethod) {
-  const client = method.getStripe();
+  const client = method.getStripeClient();
   const result = await client.customers.search({ query: `metadata['did']:'${internal.did}'` });
   if (result.data.length > 0) {
     return result.data[0] as any;
@@ -132,7 +132,7 @@ export async function ensureStripeCustomer(internal: Customer, method: PaymentMe
 }
 
 export async function ensureStripePaymentCustomer(internal: any, method: PaymentMethod) {
-  const client = method.getStripe();
+  const client = method.getStripeClient();
   let customer = null;
   if (internal.payment_details?.stripe?.customer_id) {
     customer = await client.customers.retrieve(internal.payment_details.stripe.customer_id);
@@ -149,7 +149,7 @@ export async function ensureStripePaymentIntent(
   method: PaymentMethod,
   currency: PaymentCurrency
 ) {
-  const client = method.getStripe();
+  const client = method.getStripeClient();
 
   let stripeIntent = null;
   if (internal.payment_details?.stripe?.payment_intent_id) {
@@ -193,7 +193,7 @@ export async function ensureStripeSubscription(
   items: TLineItemExpanded[],
   trialInDays: number = 0
 ) {
-  const client = method.getStripe();
+  const client = method.getStripeClient();
 
   let stripeSubscription: any = null;
   if (internal.payment_details?.stripe?.subscription_id) {
@@ -303,7 +303,7 @@ export async function forwardUsageRecordToStripe(
     return null;
   }
 
-  const client = method.getStripe();
+  const client = method.getStripeClient();
   const result = await client.subscriptionItems.createUsageRecord(subscriptionItem.metadata.stripe_id, {
     quantity: updates.quantity,
     timestamp: updates.timestamp,

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

@@ -16,7 +16,7 @@ export async function ensureWebhookRegistered() {
       continue;
     }
 
-    const stripe = method.getStripe();
+    const stripe = method.getStripeClient();
     const { data } = await stripe.webhookEndpoints.list({ limit: 100 });
 
     const exist = data.find((webhook) => webhook.metadata?.appPid === env.appPid);

package/api/src/jobs/checkout-session.ts

@@ -0,0 +1,23 @@
+import { mintNftForCheckoutSession } from '../integrations/blockchain/nft';
+import { ensurePassportIssued, ensurePassportRevoked } from '../integrations/blocklet/passport';
+import { events } from '../libs/event';
+import logger from '../libs/logger';
+import type { CheckoutSession, Subscription } from '../store/models';
+
+// eslint-disable-next-line require-await
+export async function startCheckoutSessionQueue() {
+  events.on('checkout.session.completed', (checkoutSession: CheckoutSession) => {
+    ensurePassportIssued(checkoutSession).catch((err) => {
+      logger.error('ensurePassportIssued failed', { error: err, checkoutSession: checkoutSession.id });
+    });
+    mintNftForCheckoutSession(checkoutSession.id).catch((err) => {
+      logger.error('mintNftForCheckoutSession failed', { error: err, checkoutSession: checkoutSession.id });
+    });
+  });
+
+  events.on('customer.subscription.deleted', (subscription: Subscription) => {
+    ensurePassportRevoked(subscription).catch((err) => {
+      logger.error('ensurePassportRevoked failed', { error: err, subscription: subscription.id });
+    });
+  });
+}

package/api/src/jobs/payment.ts

@@ -1,5 +1,4 @@
 import { wallet } from '../libs/auth';
-import { getClient } from '../libs/chain/arcblock';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
@@ -61,7 +60,7 @@ export const handlePayment = async (job: PaymentJob) => {
   logger.info(`PaymentIntent capture attempt: ${paymentIntent.id}`);
   try {
     await paymentIntent.update({ status: 'processing' });
-    const client = getClient(paymentMethod.settings.arcblock?.api_host as string);
+    const client = paymentMethod.getOcapClient();
     const txHash = await client.sendTransferV2Tx({
       tx: {
         itx: {

package/api/src/libs/audit.ts

@@ -3,6 +3,8 @@ import pick from 'lodash/pick';
 import { Event } from '../store/models/event';
 import { events } from './event';
 
+const API_VERSION = '2023-09-05';
+
 export async function createEvent(scope: string, type: string, model: any, options: any) {
   // console.log('createEvent', scope, type, model, options);
   const data: any = {
@@ -14,7 +16,7 @@ export async function createEvent(scope: string, type: string, model: any, optio
 
   const event = await Event.create({
     type,
-    api_version: 'v1',
+    api_version: API_VERSION,
     livemode: !!model.livemode,
     object_id: model.id,
     object_type: scope,
@@ -29,6 +31,7 @@ export async function createEvent(scope: string, type: string, model: any, optio
   });
 
   events.emit('event.created', { id: event.id });
+  events.emit(event.type, data.object);
 }
 
 export async function createStatusEvent(
@@ -55,7 +58,45 @@ export async function createStatusEvent(
   const suffix = config[data.object.status];
   const event = await Event.create({
     type: [prefix, suffix].join('.'),
-    api_version: 'v1',
+    api_version: API_VERSION,
+    livemode: !!model.livemode,
+    object_id: model.id,
+    object_type: scope,
+    data,
+    request: {
+      // FIXME:
+      id: '',
+      idempotency_key: '',
+    },
+    metadata: {},
+    pending_webhooks: 99, // force all events goto the event queue
+  });
+
+  events.emit('event.created', { id: event.id });
+  events.emit(event.type, data.object);
+}
+
+export async function createCustomEvent(
+  scope: string,
+  prefix: string,
+  type: (current: any, previous: any) => string,
+  model: any,
+  options: any
+) {
+  // console.log('createCustomEvent', scope, prefix, type, model, options);
+  const data: any = {
+    object: model.dataValues,
+    previous_attributes: pick(model._previousDataValues, options.fields),
+  };
+
+  const suffix = type(data.object, data.previous_attributes);
+  if (!suffix) {
+    return;
+  }
+
+  const event = await Event.create({
+    type: [prefix, suffix].join('.'),
+    api_version: API_VERSION,
     livemode: !!model.livemode,
     object_id: model.id,
     object_type: scope,
@@ -70,4 +111,5 @@ export async function createStatusEvent(
   });
 
   events.emit('event.created', { id: event.id });
+  events.emit(event.type, data.object);
 }

package/api/src/libs/payment.ts

@@ -4,12 +4,11 @@ import type { DelegateState } from '@ocap/client';
 import { BN } from '@ocap/util';
 
 import type { TPaymentCurrency } from '../store/models/payment-currency';
-import type { TPaymentMethod } from '../store/models/payment-method';
+import type { PaymentMethod } from '../store/models/payment-method';
 import { blocklet, wallet } from './auth';
-import { getClient } from './chain/arcblock';
 
 export async function isDelegationSufficientForPayment(args: {
-  paymentMethod: TPaymentMethod;
+  paymentMethod: PaymentMethod;
   paymentCurrency: TPaymentCurrency;
   userDid: string;
   amount: string;
@@ -23,7 +22,7 @@ export async function isDelegationSufficientForPayment(args: {
       return { sufficient: false, reason: 'NO_DID_WALLET' };
     }
 
-    const client = await getClient(paymentMethod.settings?.arcblock?.api_host as string);
+    const client = paymentMethod.getOcapClient();
 
     // have delegated before?
     const address = toDelegateAddress(delegator, wallet.address);

package/api/src/locales/en.ts

@@ -1,3 +1,11 @@
 import flat from 'flat';
 
-export default flat({});
+export default flat({
+  notification: {
+    sendTo: 'Sent to',
+    mintNFT: {
+      title: '{collection} NFT minted',
+      message: 'A new {collection} NFT is minted and sent to your wallet, please check it out.',
+    },
+  },
+});