@unchainedshop/plugins 3.1.10 → 4.0.0-rc.2

package/src/payment/cryptopay/plugin.ts

@@ -1,9 +1,3 @@
-import { ethers } from 'ethers';
-import { BIP32Factory } from 'bip32';
-import bs58check from 'bs58check';
-import * as ecc from 'tiny-secp256k1';
-import { networks, payments } from 'bitcoinjs-lib';
-import { createLogger } from '@unchainedshop/logger';
 import {
   IPaymentAdapter,
   PaymentAdapter,
@@ -11,52 +5,28 @@ import {
   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:core-payment:cryptopay');
 
 const { CRYPTOPAY_SECRET, CRYPTOPAY_BTC_XPUB, CRYPTOPAY_ETH_XPUB } = process.env;
 
-const resolvePath = (prefix) => {
-  if (prefix === 'x') return `m/44'/0'`;
-  if (prefix === 'y') return `m/49'/0'`;
-  if (prefix === 'z') return `m/84'/0'`;
-  if (prefix === 't') return `m/44'/1'`;
-  if (prefix === 'u') return `m/49'/1'`;
-  if (prefix === 'v') return `m/84'/1'`;
-  return `m`;
-};
-
-const resolveNetwork = (prefix) => {
-  if (['x', 'y', 'z'].includes(prefix)) return networks.bitcoin;
-  return networks.testnet;
-};
-
-function convertExtendedPublicKey(z) {
-  const derivationPath = resolvePath(z.slice(0, 1));
-  const network = resolveNetwork(z.slice(0, 1));
-  // https://github.com/satoshilabs/slips/blob/master/slip-0132.md
-  let data = bs58check.decode(z);
-  data = data.slice(4);
-  data = Buffer.concat([Buffer.from('0488b21e', 'hex'), data]);
-  return {
-    xpub: bs58check.encode(data),
-    network,
-    derivationPath,
-  };
-}
-
-enum CryptopayCurrencies { // eslint-disable-line
+enum CryptopayCurrencies {
   BTC = 'BTC',
   ETH = 'ETH',
 }
 
-type CryptopayAddress = {
-  currency: CryptopayCurrencies;
+interface CryptopayAddress {
+  currencyCode: CryptopayCurrencies;
   address: string;
   currencyConversionRate?: number;
   currencyConversionExpiryDate?: Date;
-};
+}
 
 const Cryptopay: IPaymentAdapter = {
   ...PaymentAdapter,
@@ -77,7 +47,7 @@ const Cryptopay: IPaymentAdapter = {
       const updatedAddresses = await Promise.all(
         existingAddresses.map(async (addressData) => {
           const targetCurrencyObj = await modules.currencies.findCurrency({
-            isoCode: addressData.currency,
+            isoCode: addressData.currencyCode,
           });
           if (!targetCurrencyObj?.isActive) return null;
           const rateData = await modules.products.prices.rates.getRate(
@@ -98,24 +68,20 @@ const Cryptopay: IPaymentAdapter = {
       orderPaymentId: string,
       cryptoAddresses: CryptopayAddress[],
     ) => {
-      return Promise.all(
-        cryptoAddresses.map(async ({ address, currency }) =>
-          modules.cryptopay.mapOrderPaymentToWalletAddress({
-            addressId: address,
-            contract: null,
-            currency,
-            orderPaymentId,
-          }),
-        ),
-      );
+      for (const cryptoAddress of cryptoAddresses) {
+        const { address, currencyCode } = cryptoAddress;
+        await modules.cryptopay.mapOrderPaymentToWalletAddress({
+          address,
+          currencyCode,
+          orderPaymentId,
+        });
+      }
     };
 
     const adapterActions = {
       ...PaymentAdapter.actions(config, context),
 
-      // eslint-disable-next-line
       configurationError() {
-        // eslint-disable-line
         if (!CRYPTOPAY_SECRET) {
           return PaymentError.INCOMPLETE_CONFIGURATION;
         }
@@ -131,7 +97,7 @@ const Cryptopay: IPaymentAdapter = {
         if (!context.order) return true;
         // if (
         //   !Object.values(CryptopayCurrencies).includes(
-        //     context.order.currency as CryptopayCurrencies,
+        //     context.order.currencyCode as CryptopayCurrencies,
         //   )
         // )
         //   return false;
@@ -144,6 +110,8 @@ const Cryptopay: IPaymentAdapter = {
 
       sign: async () => {
         const { orderPayment, order } = context;
+        if (!orderPayment)
+          throw new Error('Payment Credential Registration is not yet supported for Cryptopay');
 
         const existingAddresses = await modules.cryptopay.getWalletAddressesByOrderPaymentId(
           orderPayment._id,
@@ -151,12 +119,12 @@ const Cryptopay: IPaymentAdapter = {
         if (existingAddresses.length) {
           // Do not derive addresses a second time for order payment, return existing addresses
           const existingAddressesWithNewExpiration = await setConversionRates(
-            order.currency,
+            order.currencyCode,
             existingAddresses.map(
-              ({ _id, currency }) =>
+              ({ _id, currencyCode }) =>
                 ({
                   address: _id,
-                  currency,
+                  currencyCode,
                 }) as CryptopayAddress,
             ),
           );
@@ -165,37 +133,32 @@ const Cryptopay: IPaymentAdapter = {
 
         const cryptoAddresses: CryptopayAddress[] = [];
         if (CRYPTOPAY_BTC_XPUB) {
-          const { xpub, network } = convertExtendedPublicKey(CRYPTOPAY_BTC_XPUB);
-          const bip32 = BIP32Factory(ecc);
-          const hardenedMaster = bip32.fromBase58(xpub, network);
           const btcDerivationNumber = await modules.cryptopay.getNextDerivationNumber(
             CryptopayCurrencies.BTC,
           );
-          const child = hardenedMaster.derivePath(`0/${btcDerivationNumber}`);
+
+          const address = deriveBtcAddress(CRYPTOPAY_BTC_XPUB, btcDerivationNumber);
           cryptoAddresses.push({
-            currency: CryptopayCurrencies.BTC,
-            address: payments.p2wpkh({
-              pubkey: child.publicKey as Buffer,
-              network,
-            }).address,
+            currencyCode: CryptopayCurrencies.BTC,
+            address,
           });
         }
         if (CRYPTOPAY_ETH_XPUB) {
-          // we neuter for security reasons, it's still quite complicated for most ethereum clients to show an appropriate
-          // xpub, that's why
-          const hdWallet = ethers.HDNodeWallet.fromExtendedKey(CRYPTOPAY_ETH_XPUB);
-          const hardenedMaster = 'neuter' in hdWallet ? hdWallet.neuter() : hdWallet;
-
           const ethDerivationNumber = await modules.cryptopay.getNextDerivationNumber(
             CryptopayCurrencies.ETH,
           );
+
+          const address = deriveEthAddress(CRYPTOPAY_ETH_XPUB, ethDerivationNumber);
           cryptoAddresses.push({
-            currency: CryptopayCurrencies.ETH,
-            address: hardenedMaster.derivePath(`0/${ethDerivationNumber}`).address,
+            currencyCode: CryptopayCurrencies.ETH,
+            address,
           });
         }
 
-        const cryptoAddressesWithExpiration = await setConversionRates(order.currency, cryptoAddresses);
+        const cryptoAddressesWithExpiration = await setConversionRates(
+          order.currencyCode,
+          cryptoAddresses,
+        );
         await updateTransactionsWithOrderPaymentId(orderPayment._id, cryptoAddresses);
         return JSON.stringify(cryptoAddressesWithExpiration);
       },
@@ -213,15 +176,15 @@ const Cryptopay: IPaymentAdapter = {
 
         const pricing = OrderPricingSheet({
           calculation: order.calculation,
-          currency: order.currency,
+          currencyCode: order.currencyCode,
         });
         const totalAmount = BigInt(pricing?.total({ useNetPrice: false }).amount);
 
-        if (walletForOrderPayment.currency !== order.currency) {
+        if (walletForOrderPayment.currencyCode !== order.currencyCode) {
           const baseCurrency = await modules.currencies.findCurrency({
-            isoCode: walletForOrderPayment.currency,
+            isoCode: walletForOrderPayment.currencyCode,
           });
-          const quoteCurrency = await modules.currencies.findCurrency({ isoCode: order.currency });
+          const quoteCurrency = await modules.currencies.findCurrency({ isoCode: order.currencyCode });
 
           const { /* min, */ max } = await modules.products.prices.rates.getRateRange(
             baseCurrency,
@@ -229,9 +192,10 @@ const Cryptopay: IPaymentAdapter = {
             order.confirmed || new Date(),
           );
 
-          const convertedAmount =
-            BigInt(walletForOrderPayment.amount.toString()) /
-            10n ** (BigInt(walletForOrderPayment.decimals) - 9n);
+          const convertedAmount = denoteAmount(
+            walletForOrderPayment.amount.toString(),
+            walletForOrderPayment.decimals,
+          );
 
           // Add a Promille 🍻
           // const minAmount = parseFloat(convertedAmount.toString()) * min * 0.999;
@@ -249,10 +213,10 @@ const Cryptopay: IPaymentAdapter = {
         }
 
         if (walletForOrderPayment) {
-          // Hack: Downgrade to 8 decimals
-          const convertedAmount =
-            BigInt(walletForOrderPayment.amount.toString()) /
-            10n ** (BigInt(walletForOrderPayment.decimals) - 9n); // All crypto native prices denoted with 8 decimals
+          const convertedAmount = denoteAmount(
+            walletForOrderPayment.amount.toString(),
+            walletForOrderPayment.decimals,
+          );
 
           if (convertedAmount && convertedAmount >= totalAmount) {
             return {
@@ -266,12 +230,11 @@ const Cryptopay: IPaymentAdapter = {
 
         logger.info(
           `Cryptopay Plugin: No confirmed payments found for currency ${
-            order.currency
+            order.currencyCode
           } and addresses ${JSON.stringify(foundWalletsWithBalances)}`,
         );
 
-        /*
-        TODO:
+        /* 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.

package/src/payment/cryptopay/readme.md

@@ -1 +1,23 @@
-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'
+# 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/types.ts

@@ -1,4 +1,4 @@
-export type Address = {
+export interface Address {
   gender?: 'female' | 'male';
   title?: string;
   name?: string;
@@ -9,8 +9,8 @@ export type Address = {
   street2?: string;
   zipCode?: string;
   city?: string;
-  country?: string;
-};
+  countryCode?: string;
+}
 
 export type BillingAddress = Address & {
   countrySubdivision?: string;
@@ -40,14 +40,14 @@ export type Customer = Address & {
   ipAddress?: string;
 };
 
-export type Order = {
+export interface Order {
   articles: Record<string, unknown>;
   taxAmount: number;
   shippingAmount: number;
   discountAmount: number;
-};
+}
 
-export type DT2015Configuration = {
+export interface DT2015Configuration {
   brandColor: string;
   textColor: 'white' | 'black';
   logoType: 'circle' | 'rectangle' | 'none';
@@ -57,7 +57,7 @@ export type DT2015Configuration = {
   logoSrc: string;
   initialView: 'list' | 'grid';
   brandTitle: string;
-};
+}
 
 export type SupportedLanguage =
   | 'de'
@@ -129,7 +129,7 @@ export type TransactionStatusCode =
   | 'transmitted'
   | 'failed';
 
-export type ResponseError = {
+export interface ResponseError {
   error: {
     code:
       | 'UNKNOWN_ERROR'
@@ -157,19 +157,19 @@ export type ResponseError = {
       | 'INVALID_SETUP';
     message: string;
   };
-};
+}
 
-type Split = {
+interface Split {
   subMerchantId: string;
   amount: number;
   commission: number;
-};
+}
 
-export type Marketplace = {
+export interface Marketplace {
   splits: Split[];
-};
+}
 
-export type InitRequestPayload = {
+export interface InitRequestPayload {
   endpoint: string;
   secret: string;
   merchantId: string;
@@ -222,21 +222,21 @@ export type InitRequestPayload = {
     rememberMe?: 'true' | 'checked';
     returnMobileToken?: boolean;
   };
-};
+}
 
-export type InitResponseSuccess = {
+export interface InitResponseSuccess {
   transactionId: string;
   mobileToken?: string;
   WEC?: Record<string, unknown>;
   ['3D']?: Record<string, unknown>;
   location?: string;
-};
+}
 
-export type StatusRequestPayload = {
+export interface StatusRequestPayload {
   transactionId: string;
-};
+}
 
-export type StatusResponseSuccess = {
+export interface StatusResponseSuccess {
   transactionId: string;
   type: TransactionType;
   status: TransactionStatusCode;
@@ -265,20 +265,20 @@ export type StatusResponseSuccess = {
   SCX?: Record<string, unknown>;
   history: Record<string, unknown>[];
   ep2?: Record<string, unknown>;
-};
+}
 
-export type SecureFieldsRequestPayload = {
+export interface SecureFieldsRequestPayload {
   currency: string;
   returnUrl?: string;
   amount?: number;
   ['3D']?: Record<string, unknown>;
-};
+}
 
-export type SecureFieldsResponseSuccess = {
+export interface SecureFieldsResponseSuccess {
   transactionId: string;
-};
+}
 
-export type AuthorizeRequestPayload = {
+export interface AuthorizeRequestPayload {
   amount: number;
   currency: string;
   refno: string;
@@ -303,14 +303,14 @@ export type AuthorizeRequestPayload = {
   SWB?: Record<string, unknown>;
   airlineData?: Record<string, unknown>;
   marketplace?: Marketplace;
-};
+}
 
-export type AuthorizeResponseSuccess = {
+export interface AuthorizeResponseSuccess {
   transactionId: string;
   acquirerAuthorizationCode?: string;
-};
+}
 
-export type AuthorizeAuthenticatedRequestPayload = {
+export interface AuthorizeAuthenticatedRequestPayload {
   transactionId: string;
   refno: string;
   amount?: number;
@@ -319,13 +319,13 @@ export type AuthorizeAuthenticatedRequestPayload = {
   autoSettle?: boolean;
   CDM?: Record<string, unknown>;
   ['3D']?: Record<string, unknown>;
-};
+}
 
-export type AuthorizeAuthenticatedResponseSuccess = {
+export interface AuthorizeAuthenticatedResponseSuccess {
   acquirerAuthorizationCode: string;
-};
+}
 
-export type ValidateRequestPayload = {
+export interface ValidateRequestPayload {
   currency: string;
   refno: string;
   refno2?: string;
@@ -336,14 +336,14 @@ export type ValidateRequestPayload = {
   PAY?: Record<string, unknown>;
   APL?: Record<string, unknown>;
   ESY?: Record<string, unknown>;
-};
+}
 
-export type ValidateResponseSuccess = {
+export interface ValidateResponseSuccess {
   transactionId: string;
   acquirerAuthorizationCode?: string;
-};
+}
 
-export type SettleRequestPayload = {
+export interface SettleRequestPayload {
   transactionId: string;
   amount: number;
   currency: string;
@@ -352,12 +352,12 @@ export type SettleRequestPayload = {
   airlineData?: Record<string, unknown>;
   marketplace?: Marketplace;
   extensions?: Record<string, string>;
-};
+}
 
-export type CancelRequestPayload = {
+export interface CancelRequestPayload {
   transactionId: string;
   refno: string;
-};
+}
 
 export type InitResponse = InitResponseSuccess | ResponseError;
 

package/src/payment/datatrans-v2/getPaths.ts

@@ -8,13 +8,13 @@ const {
   DATATRANS_RETURN_PATH = '/datatrans/return',
 } = process.env;
 
-type Paths = {
+interface Paths {
   postUrl: string;
   cancelUrl: string;
   successUrl: string;
   errorUrl: string;
   returnUrl: string;
-};
+}
 
 export default (): Paths => ({
   postUrl: `${ROOT_URL}${DATATRANS_WEBHOOK_PATH}`,

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

@@ -89,11 +89,11 @@ const Datatrans: IPaymentAdapter = {
 
       const pricingForOrderPayment = PaymentPricingSheet({
         calculation: orderPayment.calculation,
-        currency: order.currency,
+        currencyCode: order.currencyCode,
       });
       const pricing = OrderPricingSheet({
         calculation: order.calculation,
-        currency: order.currency,
+        currencyCode: order.currencyCode,
       });
 
       const { amount: total } = pricing.total({ useNetPrice: false });
@@ -128,12 +128,12 @@ const Datatrans: IPaymentAdapter = {
       const refno = Buffer.from(orderPayment._id, 'hex').toString('base64');
       const userId = order?.userId || context?.userId;
       const refno2 = userId;
-      const { currency, amount } = roundedAmountFromOrder(order);
+      const { currencyCode, amount } = roundedAmountFromOrder(order);
       const splits = await getMarketplaceSplits();
       const result = await api().authorize({
         ...arbitraryFields,
         amount,
-        currency,
+        currency: currencyCode,
         refno,
         refno2,
         autoSettle: false,
@@ -158,12 +158,12 @@ const Datatrans: IPaymentAdapter = {
       ...arbitraryFields
     }): Promise<string> => {
       const { order } = context;
-      const { currency, amount } = roundedAmountFromOrder(order);
+      const { currencyCode, amount } = roundedAmountFromOrder(order);
       const result = await api().authorizeAuthenticated({
         ...arbitraryFields,
         transactionId,
         amount,
-        currency,
+        currency: currencyCode,
         refno,
         refno2,
         autoSettle: false,
@@ -174,14 +174,14 @@ const Datatrans: IPaymentAdapter = {
 
     const isTransactionAmountValid = (transaction: StatusResponseSuccess): boolean => {
       const { order } = context;
-      const { currency, amount } = roundedAmountFromOrder(order);
+      const { currencyCode, amount } = roundedAmountFromOrder(order);
       if (
-        transaction.currency !== currency ||
+        transaction.currency !== currencyCode ||
         (transaction.detail.authorize as any)?.amount !== amount
       ) {
         logger.info(
-          `currency: ${transaction.currency} === ${currency} => ${
-            transaction.currency === currency
+          `currency: ${transaction.currency} === ${currencyCode} => ${
+            transaction.currency === currencyCode
           }, amount: ${(transaction.detail.authorize as any)?.amount} === ${amount} => ${
             (transaction.detail.authorize as any)?.amount === amount
           }`,
@@ -208,14 +208,14 @@ const Datatrans: IPaymentAdapter = {
 
     const settle = async ({ transactionId, refno, refno2, extensions }): Promise<boolean> => {
       const { order } = context;
-      const { currency, amount } = roundedAmountFromOrder(order);
+      const { currencyCode, amount } = roundedAmountFromOrder(order);
       const splits = await getMarketplaceSplits();
       const result = await api().settle({
         transactionId,
         amount,
         refno,
         refno2,
-        currency,
+        currency: currencyCode,
         marketplace: splits.length
           ? {
               splits,
@@ -263,12 +263,14 @@ const Datatrans: IPaymentAdapter = {
         );
         const userId = order?.userId || context?.userId;
         const refno2 = userId;
-        const price: { amount?: number; currency?: string } = order ? roundedAmountFromOrder(order) : {};
+        const price: { amount?: number; currencyCode?: string } = order
+          ? roundedAmountFromOrder(order)
+          : {};
 
         if (useSecureFields) {
           const result = await api().secureFields({
             ...arbitraryFields,
-            currency: price.currency || 'CHF',
+            currency: price.currencyCode || 'CHF',
             refno,
             refno2,
             customer: {
@@ -281,7 +283,7 @@ const Datatrans: IPaymentAdapter = {
         }
         const result = await api().init({
           ...arbitraryFields,
-          currency: price.currency || 'CHF',
+          currency: price.currencyCode || 'CHF',
           refno,
           refno2,
           customer: {

package/src/payment/datatrans-v2/roundedAmountFromOrder.ts

@@ -1,14 +1,14 @@
 import { OrderPricingSheet } from '@unchainedshop/core';
 import { Order } from '@unchainedshop/core-orders';
 
-const roundedAmountFromOrder = (order: Order): { currency: string; amount: number } => {
+const roundedAmountFromOrder = (order: Order): { currencyCode: string; amount: number } => {
   const pricing = OrderPricingSheet({
     calculation: order.calculation,
-    currency: order.currency,
+    currencyCode: order.currencyCode,
   });
-  const { currency, amount } = pricing.total({ useNetPrice: false });
+  const { currencyCode, amount } = pricing.total({ useNetPrice: false });
   return {
-    currency,
+    currencyCode,
     amount: Math.round(amount),
   };
 };

package/src/payment/paypal-checkout.ts

@@ -90,7 +90,7 @@ const PaypalCheckout: IPaymentAdapter = {
 
           const pricing = OrderPricingSheet({
             calculation: order.calculation,
-            currency: order.currency,
+            currencyCode: order.currencyCode,
           });
           const ourTotal = (pricing.total({ useNetPrice: false }).amount / 100).toFixed(2);
           const paypalTotal = paypalOrder.result.purchase_units[0].amount.value;

package/src/payment/payrexx/api/index.ts

@@ -17,7 +17,7 @@ export enum GatewayObjectStatus {
   uncaptured = '_',
 }
 
-export type GatewayObject = {
+export interface GatewayObject {
   status: GatewayObjectStatus;
   currency: string;
   amount: number;
@@ -27,7 +27,7 @@ export type GatewayObject = {
       id: string;
     }[];
   }[];
-};
+}
 
 export type TransactionObject = any;
 

package/src/payment/payrexx/api/makeFetcher.ts

@@ -5,7 +5,7 @@ const { MOCK_APIS } = process.env;
 const logger = createLogger('unchained:payrexx');
 
 export default (
-  baseUrl: string = 'https://api.payrexx.com/v1.0/',
+  baseUrl = 'https://api.payrexx.com/v1.0/',
   instance: string = null,
   secret: string = null,
 ): ((path: string, method: 'GET' | 'DELETE' | 'PUT' | 'POST', data?: any) => Promise<Response>) => {