@unchainedshop/plugins 1.2.40 → 2.0.0-beta2

package/src/payment/cryptopay.ts

@@ -1,197 +0,0 @@
-import { Context } from '@unchainedshop/types/api';
-import { IPaymentAdapter } from '@unchainedshop/types/payments';
-import bodyParser from 'body-parser';
-import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
-import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
-import { OrderPricingSheet } from '@unchainedshop/core-orders';
-import { ethers } from 'ethers';
-import BIP32Factory from 'bip32';
-import * as ecc from 'tiny-secp256k1';
-import * as bitcoin from 'bitcoinjs-lib';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:core-payment:cryptopay');
-
-const {
-  CRYPTOPAY_SECRET,
-  CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay',
-  CRYPTOPAY_BTC_XPUB,
-  CRYPTOPAY_ETH_XPUB,
-  CRYPTOPAY_BTC_TESTNET = false,
-  CRYPTOPAY_MAX_RATE_AGE = '360', // seconds
-  CRYPTOPAY_MAX_CONV_DIFF = '0.01',
-} = process.env;
-
-enum CryptopayCurrencies { // eslint-disable-line
-  BTC = 'BTC',
-  ETH = 'ETH',
-}
-
-const MAX_RATE_AGE = parseInt(CRYPTOPAY_MAX_RATE_AGE, 10);
-const MAX_ALLOWED_DIFF = parseFloat(CRYPTOPAY_MAX_CONV_DIFF); // Accept payments when the converted amount differs by adapterActions much (in percent)
-
-export default (app) => {
-  useMiddlewareWithCurrentContext(app, CRYPTOPAY_WEBHOOK_PATH, bodyParser.json());
-
-  useMiddlewareWithCurrentContext(app, CRYPTOPAY_WEBHOOK_PATH, async (request, response) => {
-    // Return a 200 response to acknowledge receipt of the event
-    const resolvedContext = request.unchainedContext as Context;
-    const { currency, contract, decimals, address, amount, secret } = request.body;
-    if (secret !== CRYPTOPAY_SECRET) {
-      logger.warn(`Cryptopay Plugin: Invalid Cryptopay Secret provided`);
-      response.end(JSON.stringify({ success: false }));
-      return;
-    }
-    const orderPayment = await resolvedContext.modules.orders.payments.findOrderPaymentByContextData({
-      context: { cryptoAddresses: { currency, address } },
-    });
-    if (orderPayment) {
-      if (currency === CryptopayCurrencies.ETH && contract && contract !== '') {
-        const ERC20CurrencyCount = await resolvedContext.modules.currencies.count({
-          includeInactive: false,
-          contractAddress: contract,
-        });
-        if (!ERC20CurrencyCount) {
-          logger.warn(`Cryptopay Plugin: ERC20 token address ${contract} not whitelisted.`);
-          response.end(JSON.stringify({ success: false }));
-          return;
-        }
-      }
-      const order = await resolvedContext.modules.orders.findOrder({
-        orderId: orderPayment.orderId,
-      });
-      const pricing = OrderPricingSheet({
-        calculation: order.calculation,
-        currency: order.currency,
-      });
-      const totalAmount = pricing?.total({ useNetPrice: false }).amount;
-      let convertedAmount: number;
-      if (order.currency === currency) {
-        convertedAmount = amount / 10 ** (decimals - 8); // All crypto native prices denoted with 8 decimals
-      } else {
-        // Need to convert
-        const rate = await resolvedContext.modules.products.prices.rates.getRate(
-          order.currency,
-          contract && contract !== '' ? contract : currency, // Convert to the smart contract if given
-          MAX_RATE_AGE,
-        );
-        if (rate) {
-          // We assume that we are converting to a fiat currency here (with 2 decimals).
-          // Paying an order with prices in crypto in another crypto is not supported.
-          convertedAmount = Math.round((amount / 10 ** decimals) * rate * 100);
-        }
-      }
-      if (convertedAmount && convertedAmount >= totalAmount * (1 - MAX_ALLOWED_DIFF)) {
-        await resolvedContext.modules.orders.checkout(
-          order._id,
-          {
-            transactionContext: { address },
-            paymentContext: { address },
-          },
-          resolvedContext,
-        );
-        response.end(JSON.stringify({ success: true }));
-      } else {
-        logger.warn(
-          `Cryptopay Plugin: OrderPayment ${orderPayment._id} not marked as paid. Converted amount is ${convertedAmount}`,
-        );
-        response.end(JSON.stringify({ success: false }));
-      }
-    } else {
-      logger.info(
-        `Cryptopay Plugin: No orderPayment with address ${address} and currency ${currency} found`,
-      );
-      response.end(JSON.stringify({ success: false }));
-    }
-  });
-};
-
-const Cryptopay: IPaymentAdapter = {
-  ...PaymentAdapter,
-
-  key: 'shop.unchained.payment.cryptopay',
-  label: 'Cryptopay',
-  version: '1.0',
-
-  typeSupported(type) {
-    return type === 'GENERIC';
-  },
-
-  actions: (params) => {
-    const { modules } = params.context;
-
-    const adapterActions = {
-      ...PaymentAdapter.actions(params),
-
-      // eslint-disable-next-line
-      configurationError() {
-        // eslint-disable-line
-        if (!CRYPTOPAY_SECRET) {
-          return PaymentError.INCOMPLETE_CONFIGURATION;
-        }
-        return null;
-      },
-
-      isActive() {
-        if (adapterActions.configurationError() === null) return true;
-        return false;
-      },
-
-      isPayLaterAllowed() {
-        return false;
-      },
-
-      sign: async () => {
-        const { orderPayment } = params.paymentContext;
-        if (orderPayment?.context.length) {
-          // Do not derive address a second time for order payment, return existing address
-          const existingAddresses = orderPayment.context.filter((c) => c.currency);
-          if (existingAddresses) {
-            return JSON.stringify(existingAddresses);
-          }
-        }
-        const cryptoAddresses: { currency: CryptopayCurrencies; address: string }[] = [];
-        if (CRYPTOPAY_BTC_XPUB) {
-          const network = CRYPTOPAY_BTC_TESTNET ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
-          const bip32 = BIP32Factory(ecc);
-          const hardenedMaster = bip32.fromBase58(CRYPTOPAY_BTC_XPUB, network);
-          const btcDerivationNumber = await modules.orders.payments.countOrderPaymentsByContextData({
-            context: { cryptoAddresses: { currency: CryptopayCurrencies.BTC } },
-          });
-          const child = hardenedMaster.derivePath(`0/${btcDerivationNumber}`);
-          cryptoAddresses.push({
-            currency: CryptopayCurrencies.BTC,
-            address: bitcoin.payments.p2pkh({
-              pubkey: child.publicKey,
-              network,
-            }).address,
-          });
-        }
-        if (CRYPTOPAY_ETH_XPUB) {
-          const hardenedMaster = ethers.utils.HDNode.fromExtendedKey(CRYPTOPAY_ETH_XPUB);
-          const ethDerivationNumber = await modules.orders.payments.countOrderPaymentsByContextData({
-            context: { cryptoAddresses: { currency: CryptopayCurrencies.ETH } },
-          });
-          cryptoAddresses.push({
-            currency: CryptopayCurrencies.ETH,
-            address: hardenedMaster.derivePath(`0/${ethDerivationNumber}`).address,
-          });
-        }
-        await modules.orders.payments.updateContext(
-          orderPayment._id,
-          { cryptoAddresses },
-          params.context,
-        );
-        return JSON.stringify(cryptoAddresses);
-      },
-
-      charge: async (): Promise<false> => {
-        return false;
-      },
-    };
-
-    return adapterActions;
-  },
-};
-
-PaymentDirector.registerAdapter(Cryptopay);

package/src/pricing/product-price-ECB-interbank-exchange.ts

@@ -1,108 +0,0 @@
-import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
-import fetch from 'node-fetch';
-import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
-import xmlJs from 'xml-js';
-
-import Cache from './utils/cache';
-
-const CACHE_PERIOD = 60 * 60 * 24; // 1 day
-
-const SUPPORTED_CURRENCIES = [
-  'USD',
-  'JPY',
-  'BGN',
-  'CZK',
-  'DKK',
-  'GBP',
-  'HUF',
-  'PLN',
-  'RON',
-  'SEK',
-  'CHF',
-  'ISK',
-  'NOK',
-  'HRK',
-  'RUB',
-  'TRY',
-  'AUD',
-  'BRL',
-  'CAD',
-  'CNY',
-  'HKD',
-  'IDR',
-  'ILS',
-  'INR',
-  'KRW',
-  'MXN',
-  'MYR',
-  'NZD',
-  'PHP',
-  'SGD',
-  'THB',
-  'ZAR',
-];
-
-const cache = new Cache(CACHE_PERIOD);
-
-const getEURexchangeRateForCurrency = async (currency) => {
-  const response = cache.get(currency, () =>
-    fetch(`https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml`, {
-      method: 'GET',
-    })
-      .then((res) => res.text())
-      .then((text) => JSON.parse(xmlJs.xml2json(text)))
-      .then(
-        (json) =>
-          json.elements?.[0]?.elements
-            .filter((e) => e.name.toLowerCase() === 'cube')[0]
-            ?.elements[0]?.elements.filter((a) => a.attributes.currency === currency)?.[0]?.attributes,
-      ),
-  );
-  return response;
-};
-
-const ProductPriceECBIntraBankExchange: IProductPricingAdapter = {
-  ...ProductPricingAdapter,
-
-  key: 'shop.unchained.pricing.price-ECB-intrabank-exchange',
-  version: '1.0',
-  label: 'Convert EUR to X with current exchange rate',
-  orderIndex: 1,
-
-  isActivatedFor: (context) => {
-    return SUPPORTED_CURRENCIES.indexOf(context.currency) !== -1;
-  },
-
-  actions: (params) => {
-    const pricingAdapter = ProductPricingAdapter.actions(params);
-
-    return {
-      ...pricingAdapter,
-
-      calculate: async () => {
-        const { product, country, quantity, currency, modules } = params.context;
-        const { calculation = [] } = params.calculationSheet;
-        const EURprice = await modules.products.prices.price(product, {
-          country,
-          currency: 'EUR',
-          quantity,
-        });
-        if (!EURprice || !EURprice?.amount || calculation?.length) return pricingAdapter.calculate();
-
-        const exchange = await getEURexchangeRateForCurrency(currency);
-        const convertedAmount = EURprice.amount * exchange.rate;
-        pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
-        pricingAdapter.resultSheet().addItem({
-          amount: convertedAmount * quantity,
-          isTaxable: EURprice.isTaxable,
-          isNetPrice: EURprice.isNetPrice,
-          meta: { adapter: ProductPriceECBIntraBankExchange.key },
-        });
-
-        return pricingAdapter.calculate();
-      },
-    };
-  },
-};
-
-ProductPricingDirector.registerAdapter(ProductPriceECBIntraBankExchange);

package/src/pricing/product-price-coinbase-exchange.ts

@@ -1,82 +0,0 @@
-import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
-import fetch from 'node-fetch';
-import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
-
-import Cache from './utils/cache';
-
-const CACHE_PERIOD = 60 * 60 * 0.1; // 10 minutes
-const SUPPORTED_CURRENCIES = ['BTC', 'ETH', 'XRP', 'USDT', 'BCH', 'BSV', 'LTC', 'EOS', 'BNB', 'XTZ'];
-const cache = new Cache(CACHE_PERIOD);
-
-const getFiatexchangeRateForCrypto = async (base, target) => {
-  const { data } = await cache.get(`${base}-${target}`, () =>
-    fetch(`https://api.coinbase.com/v2/exchange-rates?currency=${base}`, {
-      method: 'GET',
-    }).then((res) => res.json()),
-  );
-  return data?.rates?.[target];
-};
-
-const ProductPriceCoinbaseExchange: IProductPricingAdapter = {
-  ...ProductPricingAdapter,
-
-  key: 'shop.unchained.pricing.price-coinbase-exchange',
-  version: '1.0',
-  label: 'Convert fiat/crypto to crypto with current exchange rate',
-  orderIndex: 1,
-
-  isActivatedFor: (context) => {
-    return SUPPORTED_CURRENCIES.indexOf(context.currency.toUpperCase()) !== -1;
-  },
-
-  actions: (params) => {
-    const pricingAdapter = ProductPricingAdapter.actions(params);
-    const { services, modules } = params.context;
-    return {
-      ...pricingAdapter,
-
-      calculate: async () => {
-        const { product, country, quantity, currency } = params.context;
-        const defaultCurrency = await services.countries.resolveDefaultCurrencyCode(
-          {
-            isoCode: country,
-          },
-          params.context,
-        );
-
-        const productPrice = await modules.products.prices.price(product, {
-          country,
-          currency: defaultCurrency,
-          quantity,
-        });
-
-        const { calculation = [] } = params.calculationSheet;
-
-        if (
-          !productPrice ||
-          !productPrice?.amount ||
-          calculation?.length ||
-          defaultCurrency === currency
-        )
-          return pricingAdapter.calculate();
-
-        const rate = await getFiatexchangeRateForCrypto(defaultCurrency, currency);
-
-        if (rate > 0) {
-          const convertedAmount = productPrice.amount * rate;
-          pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
-          pricingAdapter.resultSheet().addItem({
-            amount: convertedAmount * quantity,
-            isTaxable: productPrice?.isTaxable,
-            isNetPrice: productPrice?.isNetPrice,
-            meta: { adapter: ProductPriceCoinbaseExchange.key },
-          });
-        }
-
-        return pricingAdapter.calculate();
-      },
-    };
-  },
-};
-
-ProductPricingDirector.registerAdapter(ProductPriceCoinbaseExchange);

package/src/pricing/product-price-cryptopay.ts

@@ -1,27 +0,0 @@
-import { Context } from '@unchainedshop/types/api';
-import { ProductPriceRate } from '@unchainedshop/types/products.pricing';
-import bodyParser from 'body-parser';
-import { useMiddlewareWithCurrentContext } from '@unchainedshop/api';
-
-const { CRYPTOPAY_SECRET, CRYPTOPAY_PRICING_WEBHOOK_PATH = '/pricing/cryptopay' } = process.env;
-
-export default (app) => {
-  useMiddlewareWithCurrentContext(app, CRYPTOPAY_PRICING_WEBHOOK_PATH, bodyParser.json());
-
-  useMiddlewareWithCurrentContext(app, CRYPTOPAY_PRICING_WEBHOOK_PATH, async (request, response) => {
-    const resolvedContext = request.unchainedContext as Context;
-    const { baseCurrency, token, rate, timestamp, secret } = request.body;
-    if (secret !== CRYPTOPAY_SECRET) {
-      response.end(JSON.stringify({ success: false }));
-      return;
-    }
-    const rateData: ProductPriceRate = {
-      baseCurrency,
-      quoteCurrency: token,
-      rate,
-      timestamp,
-    };
-    const success = await resolvedContext.modules.products.prices.rates.updateRate(rateData);
-    response.end(JSON.stringify({ success }));
-  });
-};