@unchainedshop/plugins 1.2.40 → 2.0.0-beta2

package/src/payment/cryptopay/plugin.ts

@@ -0,0 +1,289 @@
+import { IPaymentAdapter } from '@unchainedshop/types/payments';
+import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
+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';
+import { UnchainedCore } from '@unchainedshop/types/core';
+import { OrderPricingSheet } from '@unchainedshop/core-orders';
+import { CryptopayModule } from './module/configureCryptopayModule';
+
+const logger = createLogger('unchained:core-payment:cryptopay');
+
+const {
+  CRYPTOPAY_SECRET,
+  CRYPTOPAY_BTC_XPUB,
+  CRYPTOPAY_ETH_XPUB,
+  CRYPTOPAY_BTC_TESTNET = false,
+  CRYPTOPAY_DERIVATION_START = '0',
+} = process.env;
+
+enum CryptopayCurrencies { // eslint-disable-line
+  BTC = 'BTC',
+  ETH = 'ETH',
+}
+
+type CryptopayAddress = {
+  currency: CryptopayCurrencies;
+  address: string;
+  currencyConversionRate?: number;
+  currencyConversionExpiryDate?: Date;
+};
+
+const getDerivationPath = (currency: CryptopayCurrencies, index: number): string => {
+  const address = `${(parseInt(CRYPTOPAY_DERIVATION_START, 10) || 0) + index}`;
+  if (currency === CryptopayCurrencies.ETH) {
+    const pathComponents = ethers.utils.defaultPath.split('/');
+    pathComponents[pathComponents.length - 1] = address;
+    return pathComponents.join('/');
+  }
+  if (currency === CryptopayCurrencies.BTC) {
+    return `m/44'/0'/0'/0/${address}`;
+  }
+  return `0/${address}`;
+};
+
+const Cryptopay: IPaymentAdapter = {
+  ...PaymentAdapter,
+
+  key: 'shop.unchained.payment.cryptopay',
+  label: 'Cryptopay',
+  version: '1.1',
+
+  typeSupported(type) {
+    return type === 'GENERIC';
+  },
+
+  actions: (params) => {
+    const modules = params.context.modules as UnchainedCore['modules'] & { cryptopay: CryptopayModule };
+
+    const setConversionRates = async (currencyCode: string, existingAddresses: any[]) => {
+      const originCurrencyObj = await modules.currencies.findCurrency({ isoCode: currencyCode });
+      const updatedAddresses = await Promise.all(
+        existingAddresses.map(async (addressData) => {
+          const targetCurrencyObj = await modules.currencies.findCurrency({
+            isoCode: addressData.currency,
+          });
+          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[],
+    ) => {
+      return Promise.all(
+        cryptoAddresses.map(async ({ address, currency }) =>
+          modules.cryptopay.mapOrderPaymentToWalletAddress({
+            addressId: address,
+            contract: null,
+            currency,
+            orderPaymentId,
+          }),
+        ),
+      );
+    };
+
+    const adapterActions = {
+      ...PaymentAdapter.actions(params),
+
+      // eslint-disable-next-line
+      configurationError() {
+        // eslint-disable-line
+        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 (!params.paymentContext.order) return true;
+        // if (
+        //   !Object.values(CryptopayCurrencies).includes(
+        //     params.paymentContext.order.currency as CryptopayCurrencies,
+        //   )
+        // )
+        //   return false;
+        return true;
+      },
+
+      isPayLaterAllowed() {
+        return false;
+      },
+
+      sign: async () => {
+        const { orderPayment, order } = params.paymentContext;
+
+        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.currency,
+            existingAddresses.map(
+              ({ _id, currency }) =>
+                ({
+                  address: _id,
+                  currency,
+                } as CryptopayAddress),
+            ),
+          );
+          return JSON.stringify(existingAddressesWithNewExpiration);
+        }
+
+        const cryptoAddresses: CryptopayAddress[] = [];
+        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.cryptopay.getNextDerivationNumber(
+            CryptopayCurrencies.BTC,
+          );
+          const derivationPath = getDerivationPath(CryptopayCurrencies.BTC, btcDerivationNumber);
+          const child = hardenedMaster.derivePath(derivationPath);
+          cryptoAddresses.push({
+            currency: CryptopayCurrencies.BTC,
+            address: bitcoin.payments.p2pkh({
+              pubkey: child.publicKey,
+              network,
+            }).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 hardenedMaster = ethers.utils.HDNode.fromExtendedKey(CRYPTOPAY_ETH_XPUB).neuter();
+          const ethDerivationNumber = await modules.cryptopay.getNextDerivationNumber(
+            CryptopayCurrencies.ETH,
+          );
+          const derivationPath = getDerivationPath(CryptopayCurrencies.ETH, ethDerivationNumber);
+          const cleanedForHD = derivationPath.split('/').slice(-2).join('/');
+          cryptoAddresses.push({
+            currency: CryptopayCurrencies.ETH,
+            address: hardenedMaster.derivePath(cleanedForHD).address,
+          });
+        }
+
+        const cryptoAddressesWithExpiration = await setConversionRates(order.currency, cryptoAddresses);
+        await updateTransactionsWithOrderPaymentId(orderPayment._id, cryptoAddresses);
+        return JSON.stringify(cryptoAddressesWithExpiration);
+      },
+
+      charge: async () => {
+        const { order, orderPayment } = params.paymentContext;
+
+        const foundWalletsWithBalances = await modules.cryptopay.getWalletAddressesByOrderPaymentId(
+          orderPayment._id,
+        );
+
+        const walletForOrderPayment = foundWalletsWithBalances.find(
+          (wallet) => BigInt(wallet.amount.toString()) > 0n,
+        );
+
+        const pricing = OrderPricingSheet({
+          calculation: order.calculation,
+          currency: order.currency,
+        });
+        const totalAmount = BigInt(pricing?.total({ useNetPrice: false }).amount);
+
+        if (walletForOrderPayment.currency !== order.currency) {
+          const baseCurrency = await modules.currencies.findCurrency({
+            isoCode: walletForOrderPayment.currency,
+          });
+          const quoteCurrency = await modules.currencies.findCurrency({ isoCode: order.currency });
+
+          const { /* min, */ max } = await modules.products.prices.rates.getRateRange(
+            baseCurrency,
+            quoteCurrency,
+            order.confirmed || new Date(),
+          );
+
+          const convertedAmount =
+            BigInt(walletForOrderPayment.amount.toString()) /
+            10n ** (BigInt(walletForOrderPayment.decimals) - 9n);
+
+          // Add a Promille 🍻
+          // const minAmount = parseFloat(convertedAmount.toString()) * min * 0.999;
+          const maxAmount = parseFloat(convertedAmount.toString()) * 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) {
+          // Hack: Downgrade to 8 decimals
+          const convertedAmount =
+            BigInt(walletForOrderPayment.amount.toString()) /
+            10n ** (BigInt(walletForOrderPayment.decimals) - 9n); // All crypto native prices denoted with 8 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.currency
+          } and addresses ${JSON.stringify(foundWalletsWithBalances)}`,
+        );
+
+        /*
+        TODO:
+
+        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 middleware 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

@@ -0,0 +1 @@
+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'

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

@@ -101,7 +101,7 @@ export default (app: any) => {
         } catch (e) {
           logger.error(`Datatrans Webhook: Unchained rejected to checkout with message`, e);
           res.writeHead(500);
-          res.end(JSON.stringify(e));
+          res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
           return;
         }
       }

package/src/payment/postfinance-checkout/middleware.ts

@@ -43,7 +43,7 @@ export default (app) => {
       } catch (e) {
         logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
         res.writeHead(500);
-        res.end(JSON.stringify(e));
+        res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
       }
     } else {
       logger.error(

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

@@ -36,6 +36,7 @@ const ProductPrice: IProductPricingAdapter = {
             },
             params.context,
           ));
+
         const price = await modules.products.prices.price(product, { country, currency, quantity });
         if (price) {
           const itemTotal = price.amount * quantity;

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

@@ -1,10 +1,6 @@
 import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
 import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
 
-const { RATECONVERSION_MAX_AGE = '360' } = process.env;
-
-const MAX_RATE_AGE = parseInt(RATECONVERSION_MAX_AGE, 10);
-
 const ProductPriceRateConversion: IProductPricingAdapter = {
   ...ProductPricingAdapter,
 
@@ -19,48 +15,49 @@ const ProductPriceRateConversion: IProductPricingAdapter = {
 
   actions: (params) => {
     const pricingAdapter = ProductPricingAdapter.actions(params);
-    const { services, modules } = params.context;
+    const { 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 { product, country, quantity, currency: targetCurrency } = params.context;
+
+        const { calculation = [] } = params.calculationSheet;
+        if (calculation?.length) {
+          // If we already have a price for the product,
+          // we skip this plugin because we don't need to convert
+          return pricingAdapter.calculate();
+        }
 
         const productPrice = await modules.products.prices.price(product, {
           country,
-          currency: defaultCurrency,
           quantity,
         });
 
-        const { calculation = [] } = params.calculationSheet;
-        if (
-          !productPrice ||
-          !productPrice?.amount ||
-          calculation?.length ||
-          defaultCurrency === currency
-        )
+        if (!productPrice) {
+          // We were not able to find a price for quantity & country
           return pricingAdapter.calculate();
+        }
+
+        const fromCurrencyObj = await modules.currencies.findCurrency({
+          isoCode: productPrice.currencyCode,
+        });
+        const targetCurrencyObj = await modules.currencies.findCurrency({
+          isoCode: targetCurrency,
+        });
+
+        if (!targetCurrencyObj?.isActive) return pricingAdapter.calculate();
 
-        const rate = await modules.products.prices.rates.getRate(
-          defaultCurrency,
-          currency,
-          MAX_RATE_AGE,
-        );
+        const rateData = await modules.products.prices.rates.getRate(fromCurrencyObj, targetCurrencyObj);
 
-        if (rate > 0) {
-          const convertedAmount = productPrice.amount * rate;
+        if (rateData?.rate > 0) {
+          const convertedAmount = Math.round(productPrice.amount * rateData.rate);
           pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
           pricingAdapter.resultSheet().addItem({
             amount: convertedAmount * quantity,
             isTaxable: productPrice?.isTaxable,
             isNetPrice: productPrice?.isNetPrice,
-            meta: { adapter: ProductPriceRateConversion.key },
+            meta: { adapter: ProductPriceRateConversion.key, rate: rateData.rate },
           });
         }
 

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

@@ -1,10 +1,7 @@
 import { IProductPricingAdapter } from '@unchainedshop/types/products.pricing';
-import { ProductPricingAdapter } from '@unchainedshop/core-products';
+import { ProductPricingDirector, ProductPricingAdapter } from '@unchainedshop/core-products';
 
-const roundToNext = (value, precision) =>
-  value % precision === precision / 2
-    ? value + precision / 2
-    : value + (precision - (value % precision));
+const roundToNext = (value, precision) => Math.ceil(value / precision) * precision;
 
 // String is referencing to a currency
 interface PriceRoundSettings {
@@ -76,3 +73,5 @@ export const ProductPriceRound: IProductPricingAdapter & {
     };
   },
 };
+
+ProductPricingDirector.registerAdapter(ProductPriceRound);

package/src/warehousing/google-sheets.ts

@@ -11,7 +11,7 @@ import { IWarehousingAdapter } from '@unchainedshop/types/warehousing';
 
 const { NODE_ENV, GOOGLE_SHEETS_ID, GOOGLE_SHEETS_PRIVATE_KEY_DATA } = process.env;
 
-const ttl = NODE_ENV === 'production' ? 1000 * 60 * 60 : 0; // 1 hour or 1 second
+const ttl = NODE_ENV === 'production' ? 1000 * 60 : 0; // 1 minute or 1 second
 
 const downloadSpreadsheet = async () => {
   if (!GOOGLE_SHEETS_PRIVATE_KEY_DATA || !GOOGLE_SHEETS_ID) return null;
@@ -124,8 +124,10 @@ const GoogleSheets: IWarehousingAdapter = {
     },
   ],
 
-  actions: (_, context) => {
+  actions: (config, context) => {
     return {
+      ...WarehousingAdapter.actions(config, context),
+
       isActive: () => {
         return true;
       },

package/src/warehousing/infinite-minter.ts

@@ -0,0 +1,66 @@
+import {
+  WarehousingDirector,
+  WarehousingAdapter,
+  WarehousingProviderType,
+} from '@unchainedshop/core-warehousing';
+import { ProductType } from '@unchainedshop/types/products';
+import { IWarehousingAdapter, TokenSurrogate } from '@unchainedshop/types/warehousing';
+import { generateDbObjectId } from '@unchainedshop/utils';
+
+const ETHMinter: IWarehousingAdapter = {
+  ...WarehousingAdapter,
+
+  key: 'shop.unchained.warehousing.infinite-minter',
+  version: '1.0',
+  label: 'Infinite Minter',
+  orderIndex: 0,
+
+  initialConfiguration: [{ key: 'chainId', value: '0' }],
+
+  typeSupported: (type) => {
+    return type === WarehousingProviderType.VIRTUAL;
+  },
+
+  actions: (configuration, context) => {
+    const { product, orderPosition } = context;
+    return {
+      ...WarehousingAdapter.actions(configuration, context),
+
+      isActive() {
+        return product?.type === ProductType.TokenizedProduct;
+      },
+
+      configurationError() {
+        return null;
+      },
+
+      stock: async () => {
+        return product.tokenization.supply;
+      },
+
+      tokenize: async () => {
+        // Upload Image to IPFS
+        // Upload Metadata to IPFS
+        // Store Metadata in Collection
+
+        const chainId = configuration.find(({ key }) => key === 'chainId')?.value || '0';
+        const { contractAddress, tokenId: chainTokenId } = product.tokenization;
+        const _id = generateDbObjectId();
+        const meta = {};
+
+        return [
+          {
+            _id,
+            chainTokenId,
+            contractAddress,
+            quantity: orderPosition.quantity,
+            chainId,
+            meta,
+          } as TokenSurrogate,
+        ];
+      },
+    };
+  },
+};
+
+WarehousingDirector.registerAdapter(ETHMinter);

package/src/warehousing/store.ts

@@ -19,8 +19,10 @@ const Store: IWarehousingAdapter = {
     return type === WarehousingProviderType.PHYSICAL;
   },
 
-  actions: () => {
+  actions: (configuration, context) => {
     return {
+      ...WarehousingAdapter.actions(configuration, context),
+
       isActive() {
         return true;
       },

package/src/worker/BulkImportWorker.ts

@@ -1,7 +1,6 @@
 import { IWorkerAdapter } from '@unchainedshop/types/worker';
-import { WorkerDirector } from '@unchainedshop/core-worker';
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core-worker';
 import { createLogger, LogLevel } from '@unchainedshop/logger';
-import { BaseAdapter } from '@unchainedshop/utils';
 import fs from 'fs';
 import JSONStream from 'JSONStream';
 import { EventIterator } from 'event-iterator';
@@ -48,7 +47,7 @@ const streamPayloadToBulkImporter = async (
 };
 
 export const BulkImportWorker: IWorkerAdapter<any, Record<string, unknown>> = {
-  ...BaseAdapter,
+  ...WorkerAdapter,
 
   key: 'shop.unchained.worker-plugin.bulk-import',
   label: 'Bulk Import',

package/src/worker/ZombieKillerWorker.ts

@@ -1,7 +1,6 @@
 import { IWorkerAdapter } from '@unchainedshop/types/worker';
-import { WorkerDirector } from '@unchainedshop/core-worker';
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core-worker';
 import { createLogger } from '@unchainedshop/logger';
-import { BaseAdapter } from '@unchainedshop/utils';
 
 const logger = createLogger('unchained:platform:zombie-killer');
 
@@ -17,7 +16,7 @@ export const ZombieKillerWorker: IWorkerAdapter<
     deletedFilesCount: number;
   }
 > = {
-  ...BaseAdapter,
+  ...WorkerAdapter,
 
   key: 'shop.unchained.worker-plugin.zombie-killer',
   label: 'Zombie Killer',

package/src/worker/email.ts

@@ -67,7 +67,6 @@ const EmailWorkerPlugin: IWorkerAdapter<
   key: 'shop.unchained.worker-plugin.email',
   label: 'Send a Mail through Nodemailer',
   version: '1.0',
-
   type: 'EMAIL',
 
   doWork: async ({ from, to, subject, ...rest }) => {

package/src/worker/export-token.ts

@@ -0,0 +1,33 @@
+import { IWorkerAdapter } from '@unchainedshop/types/worker';
+import { WorkerDirector, WorkerAdapter, WorkerEventTypes } from '@unchainedshop/core-worker';
+import { UnchainedCore } from '@unchainedshop/types/core';
+
+export const ExportTokenWorker: IWorkerAdapter<void, void> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.export-token',
+  label: 'External worker to hold the state of the minting/export process of tokens',
+  version: '1.0',
+  type: 'EXPORT_TOKEN',
+  external: true,
+
+  async doWork() {
+    throw new Error('Cannot do work for external workers');
+  },
+};
+
+export const configureExportToken = (unchainedApi: UnchainedCore) => {
+  WorkerDirector.events.on(WorkerEventTypes.FINISHED, async ({ work }) => {
+    if (work.type === 'EXPORT_TOKEN' && work.success) {
+      await unchainedApi.modules.warehousing.updateTokenOwnership({
+        tokenId: work.input.token._id,
+        userId: null,
+        walletAddress: work.input.recipientWalletAddress,
+      });
+    }
+  });
+};
+
+export default configureExportToken;
+
+WorkerDirector.registerAdapter(ExportTokenWorker);

package/src/worker/external.ts

@@ -8,6 +8,7 @@ export const ExternalWorkerPlugin: IWorkerAdapter<void, void> = {
   label: 'External plugin as a placeholder for workers who interact with the system only via GraphQL',
   version: '1.0',
   type: 'EXTERNAL',
+  external: true,
 
   async doWork() {
     throw new Error('Cannot do work for external workers');