@unchainedshop/plugins 4.3.5 → 4.5.0

package/src/payment/cryptopay/handle-webhook.ts

@@ -1,103 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { Context } from '@unchainedshop/api';
-import { OrderStatus } from '@unchainedshop/core-orders';
-import { CryptopayModule } from './module.js';
-import { ProductPriceRate } from '@unchainedshop/core-products';
-
-const { CRYPTOPAY_SECRET, CRYPTOPAY_MAX_RATE_AGE = '360' } = process.env;
-
-const logger = createLogger('unchained:cryptopay:handler');
-
-export default async function handleWebhook(
-  {
-    secret,
-    wallet,
-    price,
-    ping,
-  }: {
-    secret: string;
-    wallet?: {
-      address: string;
-      blockHeight: number;
-      amount: string;
-      contract?: string;
-      decimals?: number;
-      currencyCode: string;
-    };
-    price?: {
-      baseCurrency: string;
-      token: string;
-      rate: number;
-      timestamp: string; // ISO date string
-    };
-    ping?: {
-      blockHeight: number;
-      currencyCode: string;
-    };
-  },
-  context: Context & {
-    modules: CryptopayModule;
-  },
-) {
-  const { modules, services } = context;
-
-  if (secret !== CRYPTOPAY_SECRET) {
-    logger.warn(`webhook called with invalid secret`);
-    throw new Error('Secret invalid');
-  }
-
-  if (wallet) {
-    const { address, blockHeight, amount, contract, decimals, currencyCode } = wallet;
-    logger.debug('webhook received wallet data', wallet);
-    const { orderPaymentId } = await modules.cryptopay.updateWalletAddress({
-      address,
-      blockHeight,
-      amount,
-      contract,
-      decimals: decimals ?? 0,
-      currencyCode,
-    });
-
-    const orderPayment =
-      orderPaymentId &&
-      (await modules.orders.payments.findOrderPayment({
-        orderPaymentId,
-      }));
-
-    if (orderPayment) {
-      // Try to process order to next status
-      // TODO: Not sure if it's correct to use processOrder here if status is PENDING!
-      const order = await modules.orders.findOrder({ orderId: orderPayment.orderId });
-      if (order!.status === null) {
-        await services.orders.checkoutOrder(order!._id, {});
-      } else if (order!.status === OrderStatus.PENDING) {
-        await services.orders.processOrder(order!, {});
-      } else {
-        throw new Error('Already processed');
-      }
-    }
-  }
-
-  if (price) {
-    logger.debug('webhook received price data', price);
-    const { baseCurrency, token, rate, timestamp } = price;
-
-    const timestampDate = new Date(timestamp);
-    const expiresAt = new Date(new Date().getTime() + parseInt(CRYPTOPAY_MAX_RATE_AGE, 10) * 1000);
-
-    const rateData: ProductPriceRate = {
-      baseCurrency,
-      quoteCurrency: token,
-      rate,
-      expiresAt,
-      timestamp: timestampDate,
-    };
-    await modules.products.prices.rates.updateRates([rateData]);
-  }
-
-  if (ping) {
-    logger.debug('webhook received ping data', ping);
-    const { blockHeight, currencyCode } = ping;
-    await modules.cryptopay.updateMostRecentBlock(currencyCode, blockHeight);
-  }
-}

package/src/payment/cryptopay/handler-express.ts

@@ -1,21 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import handleWebhook from './handle-webhook.js';
-
-const logger = createLogger('unchained:cryptopay:handler');
-
-const cryptopayHandler = async (req, res) => {
-  if (req.method === 'POST') {
-    try {
-      await handleWebhook(req.body, req.unchainedContext);
-      res.status(200).send({ success: true });
-      return;
-    } catch (e) {
-      logger.error(e);
-      res.status(500).send({ success: false, error: e.message });
-      return;
-    }
-  }
-  res.status(404).send();
-};
-
-export default cryptopayHandler;

package/src/payment/cryptopay/handler-fastify.ts

@@ -1,24 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import handleWebhook from './handle-webhook.js';
-import { FastifyRequest, RouteHandlerMethod } from 'fastify';
-
-const logger = createLogger('unchained:cryptopay:handler');
-
-const cryptopayHandler: RouteHandlerMethod = async (
-  req: FastifyRequest & {
-    unchainedContext: any;
-  },
-  reply,
-) => {
-  try {
-    await handleWebhook(req.body as any, req.unchainedContext);
-    reply.status(200);
-    return reply.send({ success: true });
-  } catch (e) {
-    logger.error(e);
-    reply.status(500);
-    return reply.send({ success: false, error: e.message });
-  }
-};
-
-export default cryptopayHandler;

package/src/payment/cryptopay/index.ts

@@ -1,7 +0,0 @@
-import './plugin.js';
-
-import cryptopayModules, { type CryptopayModule } from './module.js';
-
-export type { CryptopayModule };
-
-export default cryptopayModules;

package/src/payment/cryptopay/module.ts

@@ -1,138 +0,0 @@
-import { mongodb } from '@unchainedshop/mongodb';
-import { CryptopayTransaction, CryptopayTransactionsCollection } from './db/CryptopayTransactions.js';
-
-const configureCryptopayModule = ({ db }) => {
-  const CryptoTransactions = CryptopayTransactionsCollection(db);
-
-  const getWalletAddress = async (
-    address: string,
-    contract?: string,
-  ): Promise<CryptopayTransaction | null> => {
-    const addressId = [address, contract].filter(Boolean).join(':');
-    return CryptoTransactions.findOne({ _id: addressId });
-  };
-
-  const updateMostRecentBlock = async (currencyCode: string, blockHeight: number): Promise<void> => {
-    await CryptoTransactions.updateMany(
-      {
-        currencyCode,
-      },
-      {
-        $set: {
-          mostRecentBlockHeight: blockHeight,
-        },
-      },
-    );
-  };
-
-  const mapOrderPaymentToWalletAddress = async ({
-    address,
-    contract,
-    currencyCode,
-    orderPaymentId,
-  }: {
-    address: string;
-    contract?: string;
-    currencyCode: string;
-    orderPaymentId: string;
-  }): Promise<CryptopayTransaction> => {
-    const addressId = [address, contract].filter(Boolean).join(':');
-
-    return (await CryptoTransactions.findOneAndUpdate(
-      {
-        _id: addressId,
-      },
-      {
-        $setOnInsert: {
-          _id: addressId,
-          currencyCode,
-          mostRecentBlockHeight: 0,
-          blockHeight: 0,
-          amount: mongodb.Decimal128.fromString('0'),
-          created: new Date(),
-        },
-        $set: {
-          orderPaymentId,
-          updated: new Date(),
-        },
-      },
-      { upsert: true, returnDocument: 'after' },
-    )) as CryptopayTransaction;
-  };
-
-  const getNextDerivationNumber = async (currencyCode: string): Promise<number> => {
-    return (await CryptoTransactions.countDocuments({ currencyCode })) + 1;
-  };
-
-  const getWalletAddressesByOrderPaymentId = async (
-    orderPaymentId: string,
-  ): Promise<CryptopayTransaction[]> => {
-    return CryptoTransactions.find(
-      {
-        orderPaymentId,
-      },
-      {
-        sort: {
-          created: 1, // Sort by creation date, most recent first
-        },
-      },
-    ).toArray();
-  };
-
-  const updateWalletAddress = async ({
-    address,
-    blockHeight,
-    amount,
-    contract,
-    currencyCode,
-    decimals,
-  }: {
-    address: string;
-    blockHeight: number;
-    amount: string | number;
-    contract?: string;
-    currencyCode: string;
-    decimals: number;
-  }): Promise<CryptopayTransaction> => {
-    const addressId = [address, contract].filter(Boolean).join(':');
-    return (await CryptoTransactions.findOneAndUpdate(
-      {
-        _id: addressId,
-      },
-      {
-        $setOnInsert: {
-          _id: addressId,
-          created: new Date(),
-        },
-        $set: {
-          currencyCode,
-          decimals,
-          blockHeight,
-          mostRecentBlockHeight: blockHeight,
-          amount: mongodb.Decimal128.fromString(typeof amount === 'number' ? `${amount}` : amount),
-          updated: new Date(),
-        },
-      },
-      { upsert: true, returnDocument: 'after' },
-    )) as CryptopayTransaction;
-  };
-
-  return {
-    getWalletAddress,
-    updateMostRecentBlock,
-    updateWalletAddress,
-    mapOrderPaymentToWalletAddress,
-    getNextDerivationNumber,
-    getWalletAddressesByOrderPaymentId,
-  };
-};
-
-export default {
-  cryptopay: {
-    configure: configureCryptopayModule,
-  },
-};
-
-export interface CryptopayModule {
-  cryptopay: ReturnType<typeof configureCryptopayModule>;
-}

package/src/payment/cryptopay/plugin.ts

@@ -1,282 +0,0 @@
-import {
-  IPaymentAdapter,
-  PaymentAdapter,
-  PaymentDirector,
-  PaymentError,
-  OrderPricingSheet,
-} from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-
-import { CryptopayModule } from './module.js';
-import deriveBtcAddress from './derive-btc-address.js';
-import deriveEthAddress from './derive-eth-address.js';
-import denoteAmount from './denote-amount.js';
-
-const logger = createLogger('unchained:cryptopay');
-
-const { CRYPTOPAY_SECRET, CRYPTOPAY_BTC_XPUB, CRYPTOPAY_ETH_XPUB } = process.env;
-
-enum CryptopayCurrencies {
-  BTC = 'BTC',
-  ETH = 'ETH',
-}
-
-interface CryptopayAddress {
-  currencyCode: CryptopayCurrencies;
-  address: string;
-  currencyConversionRate?: number;
-  currencyConversionExpiryDate?: Date;
-}
-
-const Cryptopay: IPaymentAdapter = {
-  ...PaymentAdapter,
-
-  key: 'shop.unchained.payment.cryptopay',
-  label: 'Cryptopay',
-  version: '1.0.0',
-
-  typeSupported(type) {
-    return type === 'GENERIC';
-  },
-
-  actions: (config, context) => {
-    const { modules } = context as typeof context & { modules: CryptopayModule };
-
-    const setConversionRates = async (currencyCode: string, existingAddresses: any[]) => {
-      const originCurrencyObj = await modules.currencies.findCurrency({ isoCode: currencyCode });
-
-      if (!originCurrencyObj?.isActive) throw new Error('Origin currency is not supported');
-
-      const updatedAddresses = await Promise.all(
-        existingAddresses.map(async (addressData) => {
-          const targetCurrencyObj = await modules.currencies.findCurrency({
-            isoCode: addressData.currencyCode,
-          });
-          if (!targetCurrencyObj?.isActive) return null;
-          const rateData = await modules.products.prices.rates.getRate(
-            originCurrencyObj,
-            targetCurrencyObj,
-          );
-          return {
-            ...addressData,
-            currencyConversionRate: rateData?.rate,
-            currencyConversionExpiryDate: rateData?.expiresAt,
-          };
-        }),
-      );
-      return updatedAddresses.filter(Boolean);
-    };
-
-    const updateTransactionsWithOrderPaymentId = async (
-      orderPaymentId: string,
-      cryptoAddresses: CryptopayAddress[],
-    ) => {
-      for (const cryptoAddress of cryptoAddresses) {
-        const { address, currencyCode } = cryptoAddress;
-        await modules.cryptopay.mapOrderPaymentToWalletAddress({
-          address,
-          currencyCode,
-          orderPaymentId,
-        });
-      }
-    };
-
-    const adapterActions = {
-      ...PaymentAdapter.actions(config, context),
-
-      configurationError() {
-        if (!CRYPTOPAY_SECRET) {
-          return PaymentError.INCOMPLETE_CONFIGURATION;
-        }
-        if (!CRYPTOPAY_BTC_XPUB && !CRYPTOPAY_ETH_XPUB) {
-          return PaymentError.INCOMPLETE_CONFIGURATION;
-        }
-        return null;
-      },
-
-      isActive() {
-        // Only support orders that have prices in BTC or ETH for the moment
-        if (adapterActions.configurationError() !== null) return false;
-        if (!context.order) return true;
-        // if (
-        //   !Object.values(CryptopayCurrencies).includes(
-        //     context.order.currencyCode as CryptopayCurrencies,
-        //   )
-        // )
-        //   return false;
-        return true;
-      },
-
-      isPayLaterAllowed() {
-        return false;
-      },
-
-      sign: async () => {
-        const { orderPayment, order } = context;
-        if (!orderPayment)
-          throw new Error('Payment Credential Registration is not yet supported for Cryptopay');
-
-        if (!order) throw new Error('Order context is required for signing with Cryptopay');
-
-        const existingAddresses = await modules.cryptopay.getWalletAddressesByOrderPaymentId(
-          orderPayment._id,
-        );
-        if (existingAddresses.length) {
-          // Do not derive addresses a second time for order payment, return existing addresses
-          const existingAddressesWithNewExpiration = await setConversionRates(
-            order.currencyCode,
-            existingAddresses.map(
-              ({ _id, currencyCode }) =>
-                ({
-                  address: _id,
-                  currencyCode,
-                }) as CryptopayAddress,
-            ),
-          );
-          return JSON.stringify(existingAddressesWithNewExpiration);
-        }
-
-        const cryptoAddresses: CryptopayAddress[] = [];
-        if (CRYPTOPAY_BTC_XPUB) {
-          const btcDerivationNumber = await modules.cryptopay.getNextDerivationNumber(
-            CryptopayCurrencies.BTC,
-          );
-
-          const address = deriveBtcAddress(CRYPTOPAY_BTC_XPUB, btcDerivationNumber);
-          cryptoAddresses.push({
-            currencyCode: CryptopayCurrencies.BTC,
-            address,
-          });
-        }
-        if (CRYPTOPAY_ETH_XPUB) {
-          const ethDerivationNumber = await modules.cryptopay.getNextDerivationNumber(
-            CryptopayCurrencies.ETH,
-          );
-
-          const address = deriveEthAddress(CRYPTOPAY_ETH_XPUB, ethDerivationNumber);
-          cryptoAddresses.push({
-            currencyCode: CryptopayCurrencies.ETH,
-            address,
-          });
-        }
-
-        const cryptoAddressesWithExpiration = await setConversionRates(
-          order.currencyCode,
-          cryptoAddresses,
-        );
-        await updateTransactionsWithOrderPaymentId(orderPayment._id, cryptoAddresses);
-        return JSON.stringify(cryptoAddressesWithExpiration);
-      },
-
-      charge: async () => {
-        const { order, orderPayment } = context;
-
-        if (!orderPayment)
-          throw new Error('Order Payment context is required for charging with Cryptopay');
-
-        if (!order) throw new Error('Order context is required for charging with Cryptopay');
-
-        const foundWalletsWithBalances = await modules.cryptopay.getWalletAddressesByOrderPaymentId(
-          orderPayment._id,
-        );
-
-        const walletForOrderPayment = foundWalletsWithBalances.find(
-          (wallet) => BigInt(wallet.amount.toString()) > 0n,
-        );
-
-        const pricing = OrderPricingSheet({
-          calculation: order.calculation,
-          currencyCode: order.currencyCode,
-        });
-        const totalAmount = BigInt(pricing?.total({ useNetPrice: false }).amount);
-
-        if (walletForOrderPayment && walletForOrderPayment.currencyCode !== order.currencyCode) {
-          const baseCurrency = await modules.currencies.findCurrency({
-            isoCode: walletForOrderPayment.currencyCode,
-          });
-
-          if (!baseCurrency) throw new Error('Base currency not found');
-
-          const quoteCurrency = await modules.currencies.findCurrency({ isoCode: order.currencyCode });
-
-          if (!quoteCurrency) throw new Error('Quote currency not found');
-
-          const rate = await modules.products.prices.rates.getRateRange(
-            baseCurrency,
-            quoteCurrency,
-            order.confirmed || new Date(),
-          );
-
-          if (!rate) throw new Error('No conversion rate found');
-
-          const convertedAmount = denoteAmount(
-            walletForOrderPayment.amount.toString(),
-            walletForOrderPayment.decimals,
-          );
-
-          // Add a Promille 🍻
-          // const minAmount = parseFloat(convertedAmount.toString()) * min * 0.999;
-          const maxAmount = parseFloat(convertedAmount.toString()) * rate.max * 1.001;
-
-          if (maxAmount && maxAmount >= totalAmount) {
-            // Enough sent
-            return {
-              transactionId: walletForOrderPayment._id,
-            };
-          }
-          logger.info(
-            `Cryptopay Plugin: Wallet ${walletForOrderPayment._id} balance too low (yet): ${maxAmount} < ${totalAmount}`,
-          );
-        }
-
-        if (walletForOrderPayment) {
-          const convertedAmount = denoteAmount(
-            walletForOrderPayment.amount.toString(),
-            walletForOrderPayment.decimals,
-          );
-
-          if (convertedAmount && convertedAmount >= totalAmount) {
-            return {
-              transactionId: walletForOrderPayment._id,
-            };
-          }
-          logger.info(
-            `Cryptopay Plugin: Wallet ${walletForOrderPayment._id} balance too low (yet): ${convertedAmount} < ${totalAmount}`,
-          );
-        }
-
-        logger.info(
-          `Cryptopay Plugin: No confirmed payments found for currency ${
-            order.currencyCode
-          } and addresses ${JSON.stringify(foundWalletsWithBalances)}`,
-        );
-
-        /* TODO: Crypto Handling
-
-        1. Check that generated crypto addresses are unique and no order payments share the same crypto address, only repeat when derivations completely exhausted.
-        2. When derivation path get's close to "exhaustedness" (95%), send a special e-mail alert to tell the user should generate a new xpub.
-        3. Extend the handler to report the highest seen block number so we can calculate confirmations, 
-        4. Order rejection should trigger an e-mail advising the vendor to actively send back funds
-
-        To allow paying in ETH or BTC or Tokens for CHF orders, it should work like this:
-        - When signing, we convert with what we have, if we can convert, fine, if we can't we throw an error at the client. The found rate id will be stored together with a signature of the order total + currency + an expiration date in a special collection
-        - We also return that signed payload to the client so the client can show something like Total: CHF 50.- "Pay 0.0024 BTC in the next 30 minutes" 
-        - When a payment occured, the charge function of the plugin picks up. If it can find a valid signed converted amount in the special collection, it will use that information instead of the order total to compare against.
-        - When a payment occured to late, the order payment will not be marked as paid and a report will be sent to the vendor that with information about how much to send back.
-
-        Refunds have to be 2nd priority:
-        For every case where we should "send back" money to someone, it get's difficult because we don't own the private key. On ETH, we could use permit/approve with web3 to get the permission to send those funds back. On BTC, we could use lightning invoices for the refunds but that will be fuckin compley anyway.
-
-        */
-
-        return false;
-      },
-    };
-
-    return adapterActions;
-  },
-};
-
-PaymentDirector.registerAdapter(Cryptopay);
-
-export default Cryptopay;

package/src/payment/cryptopay/readme.md

@@ -1,23 +0,0 @@
-# Cryptopay
-
-curl -X POST http://localhost:4010/payment/cryptopay -d '{ "secret": "secret", "address": "0xF5F72AE7fa1fa990ebaF163208Ed7aD6a3f42DEA", "blockHeight": 7469853, "amount": "50000000000000000", "decimals": 18, "currency": "ETH"}' -H 'Content-Type: application/json'
-
-
-## HD Key Requirements
-
-Using HD keys allows us to generate "child-keys" for every payment. This helps us link payments to checkouts and improves privacy of the vendor as we don't expose the grand total of revenue the vendor makes on the blockchain directly.
-
-**Bitcoin:**
-For the extended HD key we only support native segwit (zpub) format, so if you have a ypub for example, use this tool here to make it the correct format:
-
-https://3rditeration.github.io/btc-extended-key-converter/
-
-**Ethereum:**
-For the extended HD key we need an extended public key using the discussed derivation path here:
-https://github.com/ethereum/EIPs/issues/84
-https://github.com/satoshilabs/slips/blob/master/slip-0044.md
-
-Thus, we are deriving child keys the Metamask way:
-m/44'/60'/0'/0/0
-m/44'/60'/0'/0/1
-m/44'/60'/0'/0/...

package/src/payment/datatrans-v2/api/authorize.ts

@@ -1,17 +0,0 @@
-// https://api-reference.datatrans.ch/#operation/Authorize
-
-import { FetchDatatransFn, AuthorizeRequestPayload, AuthorizeResponse } from './types.js';
-
-export default async function authorize({
-  ...payload
-}: AuthorizeRequestPayload): Promise<AuthorizeResponse> {
-  const reqBody = {
-    ...payload,
-    autoSettle: false,
-  };
-
-  const { fetchDatatrans }: { fetchDatatrans: FetchDatatransFn } = this;
-  const result = await fetchDatatrans('/v1/transactions/authorize', reqBody);
-  const json = await result.json();
-  return json;
-}

package/src/payment/datatrans-v2/api/authorizeAuthenticated.ts

@@ -1,20 +0,0 @@
-import {
-  FetchDatatransFn,
-  AuthorizeAuthenticatedRequestPayload,
-  AuthorizeAuthenticatedResponse,
-} from './types.js';
-
-export default async function authorizeAuthenticated({
-  transactionId,
-  ...payload
-}: AuthorizeAuthenticatedRequestPayload): Promise<AuthorizeAuthenticatedResponse> {
-  const reqBody = {
-    ...payload,
-    autoSettle: false,
-  };
-
-  const { fetchDatatrans }: { fetchDatatrans: FetchDatatransFn } = this;
-  const result = await fetchDatatrans(`/v1/transactions/${transactionId}/authorize`, reqBody);
-  const json = await result.json();
-  return json;
-}

package/src/payment/datatrans-v2/api/cancel.ts

@@ -1,13 +0,0 @@
-import { FetchDatatransFn, CancelRequestPayload, CancelResponse } from './types.js';
-
-export default async function cancel({
-  transactionId,
-  ...payload
-}: CancelRequestPayload): Promise<CancelResponse> {
-  const reqBody = payload;
-  const { fetchDatatrans }: { fetchDatatrans: FetchDatatransFn } = this;
-  const result = await fetchDatatrans(`/v1/transactions/${transactionId}/cancel`, reqBody);
-  if (result.status === 204) return true;
-  const json = await result.json();
-  return json;
-}

package/src/payment/datatrans-v2/api/index.ts

@@ -1,24 +0,0 @@
-import makeFetcher from './makeFetcher.js';
-import status from './status.js';
-import init from './init.js';
-import secureFields from './secureFields.js';
-import authorize from './authorize.js';
-import validate from './validate.js';
-import settle from './settle.js';
-import cancel from './cancel.js';
-import authorizeAuthenticated from './authorizeAuthenticated.js';
-
-export default function createDatatransAPI(endpoint: string, merchantId: string, secret: string) {
-  const fetchDatatrans = makeFetcher(endpoint, merchantId, secret);
-  return {
-    fetchDatatrans,
-    init,
-    authorize,
-    validate,
-    secureFields,
-    status,
-    authorizeAuthenticated,
-    settle,
-    cancel,
-  };
-}