@unchainedshop/plugins 4.7.2 → 4.8.0

package/lib/payment/braintree.js

@@ -0,0 +1,138 @@
+import { createLogger } from '@unchainedshop/logger';
+import { PaymentAdapter, PaymentDirector, PaymentError, OrderPricingSheet, } from '@unchainedshop/core';
+const logger = createLogger('unchained:braintree');
+const { BRAINTREE_SANDBOX_TOKEN, BRAINTREE_PRIVATE_KEY } = process.env;
+let braintree;
+try {
+    const braintreePackage = await import('braintree');
+    braintree = braintreePackage.default;
+}
+catch {
+    logger.warn("npm dependency 'braintree' is not installed, paypal adapter will not work");
+}
+const BraintreeDirect = {
+    ...PaymentAdapter,
+    key: 'shop.unchained.braintree-direct',
+    label: 'Braintree Direct',
+    version: '1.0.0',
+    initialConfiguration: [
+        {
+            key: 'publicKey',
+            value: null,
+        },
+        {
+            key: 'merchantId',
+            value: null,
+        },
+    ],
+    typeSupported: (type) => {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const getPublicKey = () => {
+            return config.reduce((current, item) => {
+                if (item.key === 'publicKey')
+                    return item.value;
+                return current;
+            }, null);
+        };
+        const getMerchantId = () => {
+            return config.reduce((current, item) => {
+                if (item.key === 'merchantId')
+                    return item.value;
+                return current;
+            }, null);
+        };
+        const getAccessToken = () => {
+            return BRAINTREE_SANDBOX_TOKEN;
+        };
+        const getPrivateKey = () => {
+            return BRAINTREE_PRIVATE_KEY;
+        };
+        const getGateway = (braintree) => {
+            const accessToken = getAccessToken();
+            if (accessToken) {
+                return braintree.connect({
+                    accessToken,
+                });
+            }
+            return braintree.connect({
+                environment: braintree.Environment.Production,
+                merchantId: getMerchantId(),
+                publicKey: getPublicKey(),
+                privateKey: getPrivateKey(),
+            });
+        };
+        const adapter = {
+            ...PaymentAdapter.actions(config, context),
+            configurationError: () => {
+                const publicCredentialsValid = getAccessToken() || (getMerchantId() && getPublicKey() && getPrivateKey());
+                if (!publicCredentialsValid) {
+                    return PaymentError.WRONG_CREDENTIALS;
+                }
+                return null;
+            },
+            isActive: () => {
+                if (adapter.configurationError() === null)
+                    return true;
+                return false;
+            },
+            isPayLaterAllowed: () => {
+                return false;
+            },
+            sign: async () => {
+                const gateway = getGateway(braintree);
+                const result = await gateway.clientToken.generate({});
+                if (result.success) {
+                    return result.clientToken;
+                }
+                throw new Error('Could not retrieve the client token');
+            },
+            charge: async ({ paypalPaymentMethodNonce }) => {
+                const { order } = context;
+                if (!order)
+                    throw new Error('Order is missing in payment context');
+                if (!paypalPaymentMethodNonce)
+                    throw new Error('You have to provide paypalPaymentMethodNonce in paymentContext');
+                const gateway = getGateway(braintree);
+                const address = order.billingAddress;
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const rounded = Math.round(pricing.total({ useNetPrice: false }).amount / 10 || 0) * 10;
+                const saleRequest = {
+                    amount: rounded / 100,
+                    merchantAccountId: order.currencyCode,
+                    paymentMethodNonce: paypalPaymentMethodNonce,
+                    orderId: order.orderNumber || order._id,
+                    shipping: address
+                        ? {
+                            firstName: address.firstName,
+                            lastName: address.lastName,
+                            company: address.company,
+                            streetAddress: address.addressLine,
+                            extendedAddress: address.addressLine2,
+                            locality: address.city,
+                            region: address.regionCode,
+                            postalCode: address.postalCode,
+                            countryCodeAlpha2: address.countryCode,
+                        }
+                        : undefined,
+                    options: {
+                        submitForSettlement: true,
+                    },
+                };
+                const result = await gateway.transaction.sale(saleRequest);
+                if (result.success) {
+                    logger.info(`Braintree Plugin: ${result.message}`, saleRequest);
+                    return result;
+                }
+                logger.warn(`Braintree Plugin: ${result.message}`, saleRequest);
+                throw new Error(result.message);
+            },
+        };
+        return adapter;
+    },
+};
+PaymentDirector.registerAdapter(BraintreeDirect);

package/lib/payment/cryptopay/handler-express.d.ts

@@ -0,0 +1,2 @@
+declare const cryptopayHandler: (req: any, res: any) => Promise<void>;
+export default cryptopayHandler;

package/lib/payment/cryptopay/handler-express.js

@@ -0,0 +1,19 @@
+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/lib/payment/cryptopay/handler-fastify.d.ts

@@ -0,0 +1,3 @@
+import { type RouteHandlerMethod } from 'fastify';
+declare const cryptopayHandler: RouteHandlerMethod;
+export default cryptopayHandler;

package/lib/payment/cryptopay/handler-fastify.js

@@ -0,0 +1,17 @@
+import { createLogger } from '@unchainedshop/logger';
+import handleWebhook from "./handle-webhook.js";
+import {} from 'fastify';
+const logger = createLogger('unchained:cryptopay:handler');
+const cryptopayHandler = async (req, reply) => {
+    try {
+        await handleWebhook(req.body, 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/lib/payment/cryptopay/index.d.ts

@@ -1,5 +1,4 @@
-import type { IPlugin } from '@unchainedshop/core';
-export declare const CryptopayPlugin: IPlugin;
-export default CryptopayPlugin;
-export { Cryptopay } from './adapter.ts';
-export { type CryptopayModule } from './module.ts';
+import './plugin.ts';
+import cryptopayModules, { type CryptopayModule } from './module.ts';
+export type { CryptopayModule };
+export default cryptopayModules;

package/lib/payment/cryptopay/index.js

@@ -1,31 +1,3 @@
-import cryptopayModules from "./module.js";
-import { Cryptopay } from "./adapter.js";
-import { cryptopayWebhookHandler } from "./api.js";
-const { CRYPTOPAY_SECRET, CRYPTOPAY_BTC_XPUB, CRYPTOPAY_ETH_XPUB, CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay', } = process.env;
-export const CryptopayPlugin = {
-    key: 'shop.unchained.payment.cryptopay',
-    label: 'Cryptopay Payment Plugin',
-    version: '1.0.0',
-    adapters: [Cryptopay],
-    module: ({ db }) => ({
-        cryptopay: cryptopayModules.cryptopay.configure({ db }),
-    }),
-    routes: [
-        {
-            path: CRYPTOPAY_WEBHOOK_PATH,
-            method: 'POST',
-            handler: cryptopayWebhookHandler,
-        },
-    ],
-    onRegister: () => {
-        if (!CRYPTOPAY_SECRET) {
-            throw new Error('CRYPTOPAY_SECRET not set');
-        }
-        if (!CRYPTOPAY_BTC_XPUB && !CRYPTOPAY_ETH_XPUB) {
-            throw new Error('No CRYPTOPAY_BTC_XPUB or CRYPTOPAY_ETH_XPUB set');
-        }
-    },
-};
-export default CryptopayPlugin;
-export { Cryptopay } from "./adapter.js";
-export {} from "./module.js";
+import "./plugin.js";
+import cryptopayModules, {} from "./module.js";
+export default cryptopayModules;

package/lib/payment/cryptopay/plugin.d.ts

@@ -0,0 +1,3 @@
+import { type IPaymentAdapter } from '@unchainedshop/core';
+declare const Cryptopay: IPaymentAdapter;
+export default Cryptopay;

package/lib/payment/cryptopay/plugin.js

@@ -0,0 +1,159 @@
+import { PaymentAdapter, PaymentDirector, PaymentError, OrderPricingSheet, } from '@unchainedshop/core';
+import { createLogger } from '@unchainedshop/logger';
+import {} 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;
+const CryptopayCurrencies = {
+    BTC: 'BTC',
+    ETH: 'ETH',
+};
+const Cryptopay = {
+    ...PaymentAdapter,
+    key: 'shop.unchained.payment.cryptopay',
+    label: 'Cryptopay',
+    version: '1.0.0',
+    typeSupported(type) {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const { modules } = context;
+        const setConversionRates = async (currencyCode, existingAddresses) => {
+            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, cryptoAddresses) => {
+            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() {
+                if (adapterActions.configurationError() !== null)
+                    return false;
+                if (!context.order)
+                    return true;
+                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) {
+                    const existingAddressesWithNewExpiration = await setConversionRates(order.currencyCode, existingAddresses.map(({ _id, currencyCode }) => ({
+                        address: _id,
+                        currencyCode,
+                    })));
+                    return JSON.stringify(existingAddressesWithNewExpiration);
+                }
+                const cryptoAddresses = [];
+                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);
+                    const maxAmount = parseFloat(convertedAmount.toString()) * rate.max * 1.001;
+                    if (maxAmount && maxAmount >= totalAmount) {
+                        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)}`);
+                return false;
+            },
+        };
+        return adapterActions;
+    },
+};
+PaymentDirector.registerAdapter(Cryptopay);
+export default Cryptopay;

package/lib/payment/datatrans-v2/handler-express.d.ts

@@ -0,0 +1 @@
+export declare const datatransHandler: (req: any, res: any) => Promise<void>;

package/lib/payment/datatrans-v2/handler-express.js

@@ -0,0 +1,71 @@
+import { createLogger } from '@unchainedshop/logger';
+import generateSignature, { Security } from "./generateSignature.js";
+const { DATATRANS_SIGN_KEY, DATATRANS_SIGN2_KEY, DATATRANS_SECURITY = Security.DYNAMIC_SIGN, } = process.env;
+const logger = createLogger('unchained:datatrans:handler');
+export const datatransHandler = async (req, res) => {
+    const resolvedContext = req.unchainedContext;
+    const { modules, services } = resolvedContext;
+    const signature = req.headers['datatrans-signature'];
+    if (!DATATRANS_SIGN_KEY && !DATATRANS_SIGN2_KEY) {
+        logger.warn('No sign key configured');
+        res.status(404).end();
+        return;
+    }
+    if (req.method === 'POST' && signature) {
+        const [rawTimestamp, rawHash] = signature.split(',');
+        const [, hash] = rawHash.split('=');
+        const [, timestamp] = rawTimestamp.split('=');
+        const comparableSignature = await generateSignature({
+            security: DATATRANS_SECURITY,
+            signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
+        })(timestamp, req.body);
+        if (hash !== comparableSignature) {
+            logger.error(`hash mismatch: ${signature} / ${comparableSignature}`);
+            res.status(403).send('Hash mismatch');
+            return;
+        }
+        const transaction = JSON.parse(req.body);
+        logger.info(`received request`, {
+            type: transaction.type,
+        });
+        if (transaction.status === 'authorized') {
+            const userId = transaction.refno2;
+            const referenceId = Buffer.from(transaction.refno, 'base64').toString('hex');
+            try {
+                if (transaction.type === 'card_check') {
+                    const paymentProviderId = referenceId;
+                    const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, { userId, transactionContext: { transactionId: transaction.transactionId } });
+                    logger.info(`registered payment credentials for ${userId}`, {
+                        userId,
+                    });
+                    res.status(200).send(paymentCredentials);
+                    return;
+                }
+                if (transaction.type === 'payment') {
+                    const orderPaymentId = referenceId;
+                    const orderPayment = await modules.orders.payments.findOrderPayment({
+                        orderPaymentId,
+                    });
+                    if (!orderPayment)
+                        throw new Error(`Order Payment with id ${orderPaymentId} not found`);
+                    const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+                        paymentContext: { userId, transactionId: transaction.transactionId },
+                    });
+                    if (!order)
+                        throw new Error(`Order with id ${orderPayment.orderId} not found`);
+                    logger.info(`confirmed checkout for order ${order.orderNumber}`, {
+                        orderId: order._id,
+                    });
+                    res.status(200).send(order);
+                    return;
+                }
+            }
+            catch (e) {
+                logger.error(`rejected to checkout: ${e.name} - ${e.message}`);
+                res.status(500).send({ name: e.name, code: e.code, message: e.message });
+                return;
+            }
+        }
+    }
+    res.status(404).end();
+};

package/lib/payment/datatrans-v2/handler-fastify.d.ts

@@ -0,0 +1,2 @@
+import type { RouteHandlerMethod } from 'fastify';
+export declare const datatransHandler: RouteHandlerMethod;

package/lib/payment/datatrans-v2/handler-fastify.js

@@ -0,0 +1,71 @@
+import { createLogger } from '@unchainedshop/logger';
+import generateSignature, { Security } from "./generateSignature.js";
+const { DATATRANS_SIGN_KEY, DATATRANS_SIGN2_KEY, DATATRANS_SECURITY = Security.DYNAMIC_SIGN, } = process.env;
+const logger = createLogger('unchained:datatrans:handler');
+export const datatransHandler = async (req, reply) => {
+    const resolvedContext = req.unchainedContext;
+    const { modules, services } = resolvedContext;
+    const signature = req.headers['datatrans-signature'];
+    if (!DATATRANS_SIGN_KEY && !DATATRANS_SIGN2_KEY) {
+        logger.warn('No sign key configured');
+        return reply.send({ success: false, message: 'No sign key configured', name: 'NO_SIGN_KEY' });
+    }
+    if (signature) {
+        const [rawTimestamp, rawHash] = signature.split(',');
+        const [, hash] = rawHash.split('=');
+        const [, timestamp] = rawTimestamp.split('=');
+        const comparableSignature = await generateSignature({
+            security: DATATRANS_SECURITY,
+            signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
+        })(timestamp, req.body);
+        if (hash !== comparableSignature) {
+            logger.error(`hash mismatch: ${signature} / ${comparableSignature}`);
+            reply.status(403);
+            return reply.send({ success: false, message: 'Invalid Signature', name: 'HASH_MISMATCH' });
+        }
+        const transaction = JSON.parse(req.body);
+        logger.info(`received request`, {
+            type: transaction.type,
+        });
+        if (transaction.status === 'authorized') {
+            const userId = transaction.refno2;
+            const referenceId = Buffer.from(transaction.refno, 'base64').toString('hex');
+            try {
+                if (transaction.type === 'card_check') {
+                    const paymentProviderId = referenceId;
+                    const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, { userId, transactionContext: { transactionId: transaction.transactionId } });
+                    logger.info(`registered payment credentials for ${userId}`, {
+                        userId,
+                    });
+                    reply.status(200);
+                    return reply.send(paymentCredentials);
+                }
+                if (transaction.type === 'payment') {
+                    const orderPaymentId = referenceId;
+                    const orderPayment = await modules.orders.payments.findOrderPayment({
+                        orderPaymentId,
+                    });
+                    if (!orderPayment)
+                        throw new Error(`Order Payment with id ${orderPaymentId} not found`);
+                    const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+                        paymentContext: { userId, transactionId: transaction.transactionId },
+                    });
+                    if (!order)
+                        throw new Error(`Order with id ${orderPayment.orderId} not found`);
+                    reply.status(200);
+                    logger.info(`confirmed checkout for order ${order.orderNumber}`, {
+                        orderId: order._id,
+                    });
+                    return reply.send(order);
+                }
+            }
+            catch (e) {
+                logger.error(e);
+                reply.status(500);
+                return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
+            }
+        }
+    }
+    reply.status(404);
+    return reply.send();
+};

package/lib/payment/datatrans-v2/index.d.ts

@@ -1,4 +1 @@
-import type { IPlugin } from '@unchainedshop/core';
-export declare const DatatransPlugin: IPlugin;
-export default DatatransPlugin;
-export { Datatrans } from './adapter.ts';
+export {};