@unchainedshop/plugins 1.1.3 → 1.1.7

package/src/payment/cryptopay.ts

@@ -0,0 +1,195 @@
+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 = '/graphql/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)
+
+useMiddlewareWithCurrentContext(CRYPTOPAY_WEBHOOK_PATH, bodyParser.json());
+
+useMiddlewareWithCurrentContext(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: { 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: { 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: { 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 () => {
+        return false;
+      },
+    };
+
+    return adapterActions;
+  },
+};
+
+PaymentDirector.registerAdapter(Cryptopay);

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

@@ -0,0 +1,17 @@
+// https://api-reference.datatrans.ch/#operation/Authorize
+
+import type { FetchDatatransFn, AuthorizeRequestPayload, AuthorizeResponse } from './types';
+
+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

@@ -0,0 +1,20 @@
+import type {
+  FetchDatatransFn,
+  AuthorizeAuthenticatedRequestPayload,
+  AuthorizeAuthenticatedResponse,
+} from './types';
+
+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

@@ -0,0 +1,13 @@
+import type { FetchDatatransFn, CancelRequestPayload, CancelResponse } from './types';
+
+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

@@ -0,0 +1,24 @@
+import makeFetcher from './makeFetcher';
+import status from './status';
+import init from './init';
+import secureFields from './secureFields';
+import authorize from './authorize';
+import validate from './validate';
+import settle from './settle';
+import cancel from './cancel';
+import authorizeAuthenticated from './authorizeAuthenticated';
+
+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,
+  };
+}

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

@@ -0,0 +1,40 @@
+// https://api-reference.datatrans.ch/#operation/init
+import getPaths from '../getPaths';
+
+import type { FetchDatatransFn, InitRequestPayload, InitResponse } from './types';
+
+const defaultRedirect = getPaths();
+
+export default async function init({
+  option,
+  redirect: userRedirect,
+  ...payload
+}: InitRequestPayload): Promise<InitResponse> {
+  const redirect = {
+    ...defaultRedirect,
+    ...(userRedirect || {}),
+  } as Partial<typeof defaultRedirect>;
+  delete redirect?.postUrl;
+  delete redirect?.returnUrl;
+
+  const reqBody = {
+    ...payload,
+    autoSettle: false,
+    option: {
+      ...(option || {}),
+      createAlias: true,
+      returnCustomerCountry: true,
+      authenticationOnly: false,
+    },
+    redirect,
+  };
+
+  const { fetchDatatrans }: { fetchDatatrans: FetchDatatransFn } = this;
+  const result = await fetchDatatrans('/v1/transactions', reqBody);
+  const json = await result.json();
+  const location = result.headers?.get('location');
+  return {
+    location,
+    ...json,
+  };
+}

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

@@ -0,0 +1,49 @@
+import fs from 'fs';
+import util from 'util';
+import { resolve } from 'path';
+import { log, LogLevel } from '@unchainedshop/logger';
+
+const readFile = util.promisify(fs.readFile);
+
+const { DATATRANS_API_MOCKS_PATH } = process.env;
+
+export default (
+  endpoint: string,
+  merchantId: string,
+  secret: string,
+): ((path: string) => Promise<Response>) => {
+  if (DATATRANS_API_MOCKS_PATH) {
+    return async (path): Promise<Response> => {
+      try {
+        const filePath = resolve(process.env.PWD, DATATRANS_API_MOCKS_PATH, `.${path}.json`);
+        const content = await readFile(filePath);
+        const json = JSON.parse(content.toString());
+        return {
+          json: async () => json,
+          status: json?.error ? 500 : 204,
+        };
+      } catch (error) {
+        log('DataTrans V2 (makeFetcher) -> Error while trying reading and parsing file', {
+          level: LogLevel.Error,
+          ...error,
+        });
+        return {
+          json: async () => ({ error: { code: 'MOCK', message: 'MOCK' } }),
+          status: 500,
+        };
+      }
+    };
+  }
+
+  const token = `${merchantId}:${secret}`;
+
+  return async (path: string, body: unknown): Promise<Response> =>
+    fetch(`${endpoint}${path}`, {
+      method: body ? 'POST' : 'GET',
+      body: body ? JSON.stringify(body) : undefined,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Basic ${Buffer.from(token, 'utf-8').toString('base64')}`,
+      },
+    });
+};

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

@@ -0,0 +1,19 @@
+// https://api-reference.datatrans.ch/#operation/init
+import getPaths from '../getPaths';
+
+import type { FetchDatatransFn, SecureFieldsRequestPayload, SecureFieldsResponse } from './types';
+
+const defaultRedirect = getPaths();
+
+export default async function secureFields(
+  payload: SecureFieldsRequestPayload,
+): Promise<SecureFieldsResponse> {
+  const reqBody = {
+    returnUrl: defaultRedirect.returnUrl,
+    ...payload,
+  };
+  const { fetchDatatrans }: { fetchDatatrans: FetchDatatransFn } = this;
+  const result = await fetchDatatrans('/v1/transactions/secureFields', reqBody);
+  const json = await result.json();
+  return json;
+}

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

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

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

@@ -0,0 +1,8 @@
+import type { FetchDatatransFn, StatusRequestPayload, StatusResponse } from './types';
+
+export default async function status({ transactionId }: StatusRequestPayload): Promise<StatusResponse> {
+  const { fetchDatatrans }: { fetchDatatrans: FetchDatatransFn } = this;
+  const result = await fetchDatatrans(`/v1/transactions/${transactionId}`);
+  const json = await result.json();
+  return json;
+}