@unchainedshop/plugins 4.8.25 → 4.8.26

package/lib/payment/apple-iap/api.js

@@ -1,119 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import { fixPeriods } from "./fix-periods.js";
-const logger = createLogger('unchained:apple-iap');
-const { APPLE_IAP_SHARED_SECRET } = process.env;
-const AppleNotificationTypes = {
-    INITIAL_BUY: 'INITIAL_BUY',
-    DID_RECOVER: 'DID_RECOVER',
-    DID_CHANGE_RENEWAL_STATUS: 'DID_CHANGE_RENEWAL_STATUS',
-    DID_FAIL_TO_RENEW: 'DID_FAIL_TO_RENEW',
-    DID_CHANGE_RENEWAL_PREF: 'DID_CHANGE_RENEWAL_PREF',
-};
-export async function appleIAPWebhookHandler(request, context) {
-    try {
-        const { modules, services } = context;
-        const responseBody = (await request.json());
-        if (responseBody.password !== APPLE_IAP_SHARED_SECRET) {
-            logger.warn('Apple IAP Webhook: Invalid shared secret');
-            return new Response(JSON.stringify({
-                error: 'Invalid shared secret',
-                name: 'AuthenticationError',
-                code: 'INVALID_SECRET',
-            }), {
-                status: 403,
-                headers: { 'Content-Type': 'application/json' },
-            });
-        }
-        const transactions = responseBody?.unified_receipt?.latest_receipt_info;
-        const latestTransaction = transactions?.[0];
-        if (!latestTransaction) {
-            throw new Error('No transaction found in receipt');
-        }
-        if (responseBody.notification_type === AppleNotificationTypes.INITIAL_BUY) {
-            const orderPayment = await modules.orders.payments.findOrderPaymentByTransactionId(latestTransaction.transaction_id);
-            if (!orderPayment) {
-                throw new Error('Could not find any matching order payment');
-            }
-            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-                paymentContext: {
-                    receiptData: responseBody?.unified_receipt?.latest_receipt,
-                },
-            });
-            if (!order) {
-                throw new Error(`Order with id ${orderPayment.orderId} not found`);
-            }
-            const orderId = order._id;
-            const enrollment = await modules.enrollments.findEnrollment({
-                orderId,
-            });
-            if (!enrollment) {
-                throw new Error('Could not find any matching enrollment');
-            }
-            await fixPeriods({
-                transactionId: latestTransaction.original_transaction_id,
-                transactions,
-                enrollmentId: enrollment._id,
-                orderId,
-            }, context);
-            logger.info(`Apple IAP Webhook: Confirmed checkout for order ${order.orderNumber}`, {
-                orderId: order._id,
-            });
-        }
-        else {
-            const originalOrderPayment = await modules.orders.payments.findOrderPaymentByTransactionId(latestTransaction.original_transaction_id);
-            if (!originalOrderPayment) {
-                throw new Error('Could not find any matching order payment');
-            }
-            const originalOrder = await modules.orders.findOrder({
-                orderId: originalOrderPayment.orderId,
-            });
-            const enrollment = originalOrder &&
-                (await modules.enrollments.findEnrollment({
-                    orderId: originalOrder._id,
-                }));
-            if (!enrollment?.payment) {
-                throw new Error('Could not find a valid enrollment payment method');
-            }
-            await services.orders.registerPaymentCredentials(enrollment.payment.paymentProviderId, {
-                transactionContext: {
-                    receiptData: responseBody?.unified_receipt?.latest_receipt,
-                },
-                userId: enrollment.userId,
-            });
-            await fixPeriods({
-                transactionId: latestTransaction.original_transaction_id,
-                transactions,
-                enrollmentId: enrollment._id,
-                orderId: originalOrder._id,
-            }, context);
-            logger.info(`Apple IAP Webhook: Processed notification for ${latestTransaction.original_transaction_id} and type ${responseBody.notification_type}`);
-            if (responseBody.notification_type === AppleNotificationTypes.DID_RECOVER) {
-                if (enrollment.status !== EnrollmentStatus.TERMINATED &&
-                    responseBody.auto_renew_status === 'false') {
-                    await services.enrollments.terminateEnrollment(enrollment);
-                }
-            }
-            if (responseBody.notification_type === AppleNotificationTypes.DID_CHANGE_RENEWAL_STATUS) {
-                if (enrollment.status !== EnrollmentStatus.TERMINATED &&
-                    responseBody.auto_renew_status === 'false') {
-                    await services.enrollments.terminateEnrollment(enrollment);
-                }
-            }
-            logger.info('Apple IAP Webhook: Updated enrollment from Apple');
-        }
-        return new Response(null, { status: 200 });
-    }
-    catch (error) {
-        logger.error('Apple IAP Webhook error:', error);
-        return new Response(JSON.stringify({
-            success: false,
-            error: error.message,
-            name: error.name,
-            code: error.code,
-        }), {
-            status: 503,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    }
-}

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

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

package/lib/payment/cryptopay/adapter.js

@@ -1,157 +0,0 @@
-import { PaymentAdapter, 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',
-};
-export 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;
-    },
-};

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

@@ -1,2 +0,0 @@
-import type { UnchainedCore } from '@unchainedshop/core';
-export declare function cryptopayWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;

package/lib/payment/cryptopay/api.js

@@ -1,23 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import handleWebhook from "./handle-webhook.js";
-const logger = createLogger('unchained:cryptopay');
-export async function cryptopayWebhookHandler(request, context) {
-    try {
-        const body = (await request.json());
-        await handleWebhook(body, context);
-        return new Response(JSON.stringify({ success: true }), {
-            status: 200,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    }
-    catch (error) {
-        logger.error('Cryptopay webhook error:', error);
-        return new Response(JSON.stringify({
-            success: false,
-            error: error.message,
-        }), {
-            status: 500,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    }
-}

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

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