@unchainedshop/plugins 4.3.5 → 4.5.0

package/src/payment/apple-iap/handler-fastify.ts

@@ -1,147 +0,0 @@
-import { Context } from '@unchainedshop/api';
-import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import { createLogger } from '@unchainedshop/logger';
-import { fixPeriods } from './fix-periods.js';
-import { FastifyRequest, RouteHandlerMethod } from 'fastify';
-import { AppleTransactionsModule } from './module.js';
-
-const logger = createLogger('unchained:apple-iap:handler');
-
-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 const appleIAPHandler: RouteHandlerMethod = async (
-  req: FastifyRequest & {
-    unchainedContext: Context & {
-      modules: AppleTransactionsModule;
-    };
-  },
-  reply,
-) => {
-  try {
-    const resolvedContext = req.unchainedContext as Context;
-    const { modules, services } = resolvedContext;
-    const responseBody: Record<string, any> = req.body || {};
-    if (responseBody.password !== APPLE_IAP_SHARED_SECRET) {
-      throw new Error('shared secret not valid');
-    }
-
-    const transactions = responseBody?.unified_receipt?.latest_receipt_info;
-    const latestTransaction = transactions[0];
-
-    if (responseBody.notification_type === AppleNotificationTypes.INITIAL_BUY) {
-      // Find the cart to checkout
-      const orderPayment = await modules.orders.payments.findOrderPaymentByContextData({
-        context: {
-          'meta.transactionIdentifier': 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('Enrollent not found');
-
-      await fixPeriods(
-        {
-          transactionId: latestTransaction.original_transaction_id,
-          transactions,
-          enrollmentId: enrollment._id,
-          orderId,
-        },
-        resolvedContext,
-      );
-
-      logger.info(`Webhook confirmed checkout for order ${order.orderNumber}`, {
-        orderId: order._id,
-      });
-    } else {
-      // Just store payment credentials, use the enrollments paymentProvider reference and
-      // let the job do the rest
-      const originalOrderPayment = await modules.orders.payments.findOrderPaymentByContextData({
-        context: {
-          'meta.transactionIdentifier': 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,
-        },
-        resolvedContext,
-      );
-
-      logger.info(
-        `Webhook rocessed 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`);
-    }
-
-    reply.status(200);
-    return reply.send();
-  } catch (e) {
-    logger.error(e);
-    reply.status(503);
-    return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
-  }
-};
-
-export default appleIAPHandler;

package/src/payment/apple-iap/index.ts

@@ -1,6 +0,0 @@
-export * from './adapter.js';
-
-import appleTransactionsModule, { type AppleTransactionsModule } from './module.js';
-
-export type { AppleTransactionsModule };
-export default appleTransactionsModule;

package/src/payment/apple-iap/module.ts

@@ -1,34 +0,0 @@
-import { generateDbObjectId } from '@unchainedshop/mongodb';
-import { AppleTransaction, AppleTransactionsCollection } from './db/AppleTransactionsCollection.js';
-
-export const configureAppleTransactionsModule = async ({ db }) => {
-  const AppleTransactions = await AppleTransactionsCollection(db);
-
-  return {
-    findTransactionById: async (transactionIdentifier: string): Promise<AppleTransaction | null> => {
-      return AppleTransactions.findOne({ _id: transactionIdentifier });
-    },
-
-    createTransaction: async (
-      doc: Omit<AppleTransaction, '_id' | 'created'> &
-        Pick<Partial<AppleTransaction>, '_id' | 'created'>,
-    ) => {
-      const { insertedId } = await AppleTransactions.insertOne({
-        _id: generateDbObjectId(),
-        ...doc,
-        created: new Date(),
-      });
-      return insertedId;
-    },
-  };
-};
-
-export default {
-  appleTransactions: {
-    configure: configureAppleTransactionsModule,
-  },
-};
-
-export interface AppleTransactionsModule {
-  appleTransactions: Awaited<ReturnType<typeof configureAppleTransactionsModule>>;
-}

package/src/payment/apple-iap/verify-receipt.ts

@@ -1,27 +0,0 @@
-const { APPLE_IAP_ENVIRONMENT = 'sandbox' } = process.env;
-
-// https://developer.apple.com/documentation/storekit/in-app_purchase/validating_receipts_with_the_app_store
-const environments = {
-  sandbox: 'https://sandbox.itunes.apple.com/verifyReceipt',
-  production: 'https://buy.itunes.apple.com/verifyReceipt',
-};
-
-export const verifyReceipt = async ({ receiptData, password }): Promise<any> => {
-  const payload: any = {
-    'receipt-data': receiptData,
-  };
-  if (password) {
-    payload.password = password;
-  }
-  const result = await fetch(environments[APPLE_IAP_ENVIRONMENT], {
-    body: JSON.stringify(payload),
-    method: 'POST',
-    // eslint-disable-next-line
-    // @ts-ignore
-    duplex: 'half',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-  });
-  return result.json();
-};

package/src/payment/braintree.ts

@@ -1,167 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import {
-  IPaymentAdapter,
-  PaymentAdapter,
-  PaymentDirector,
-  PaymentError,
-  OrderPricingSheet,
-} from '@unchainedshop/core';
-const logger = createLogger('unchained:braintree');
-
-const { BRAINTREE_SANDBOX_TOKEN, BRAINTREE_PRIVATE_KEY } = process.env;
-
-let braintree: any;
-try {
-  // eslint-disable-next-line
-  // @ts-ignore
-  const braintreePackage = await import('braintree');
-  braintree = braintreePackage.default;
-} catch {
-  /* */
-  logger.warn("npm dependency 'braintree' is not installed, paypal adapter will not work");
-}
-
-const BraintreeDirect: IPaymentAdapter = {
-  ...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) {
-        // sandbox mode!
-        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/src/payment/cryptopay/db/CryptopayTransactions.ts

@@ -1,16 +0,0 @@
-import { mongodb } from '@unchainedshop/mongodb';
-import { TimestampFields } from '@unchainedshop/mongodb';
-
-export type CryptopayTransaction = {
-  _id: string;
-  blockHeight: number;
-  mostRecentBlockHeight: number;
-  amount: mongodb.Decimal128;
-  currencyCode: string;
-  decimals: number;
-  orderPaymentId?: string;
-} & TimestampFields;
-
-export const CryptopayTransactionsCollection = (db: mongodb.Db) => {
-  return db.collection<CryptopayTransaction>('cryptopay_transactions');
-};

package/src/payment/cryptopay/denote-amount.test.ts

@@ -1,28 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import denoteAmount from './denote-amount.js';
-
-describe('Denote Amount', () => {
-  it('Handle amount with 18 decimals', () => {
-    // For example, Ethereum uses 18 decimals, this converts WEI to GWei
-    assert.equal(denoteAmount('1000000000000000000', 18), 1000000000n);
-    assert.equal(denoteAmount('100000000000000', 18), 100000n);
-    assert.equal(denoteAmount('100', 18), 0n);
-  });
-  it('Handle amount with 10 decimals', () => {
-    assert.equal(denoteAmount('100000000', 10), 10000000n);
-    assert.equal(denoteAmount('100000000000000', 10), 10000000000000n);
-    assert.equal(denoteAmount('100', 10), 10n);
-  });
-  it('Handle amount with 8 decimals', () => {
-    // For example, Bitcoin uses 8 decimals, this keeps Satoshi as is
-    assert.equal(denoteAmount('100000000', 8), 100000000n);
-    assert.equal(denoteAmount('100000000000000', 8), 100000000000000n);
-    assert.equal(denoteAmount('1', 8), 1n);
-  });
-  it('Handle amount with 2 decimals', () => {
-    assert.equal(denoteAmount('100000000', 2), 100000000n);
-    assert.equal(denoteAmount('100000000000000', 2), 100000000000000n);
-    assert.equal(denoteAmount('1', 2), 1n);
-  });
-});

package/src/payment/cryptopay/denote-amount.ts

@@ -1,29 +0,0 @@
-/**
- * Converts a cryptocurrency amount from its smallest unit (e.g., wei, satoshi) to a normalized value
- * with 9 decimal places of precision.
- *
- * This function handles the denomination of cryptocurrency amounts by converting from the
- * blockchain's native smallest units (like wei for Ethereum which is 10^-18 ETH, or satoshi for Bitcoin
- * which is 10^-8 BTC) to a standardized format with 9 decimal places for consistent handling across
- * different cryptocurrencies.
- *
- * @param {string} amountAsString - The amount in the cryptocurrency's smallest unit (e.g., wei, satoshi)
- *                                  represented as a string to handle large numbers
- * @param {number} decimals - The number of decimal places used by the cryptocurrency
- *                           (e.g., 18 for Ethereum, 8 for Bitcoin)
- * @returns {number} The converted amount with 9 decimal places of precision
- *
- * @example
- * // Convert 1 ETH in wei (1000000000000000000) to normalized format
- * denoteAmount("1000000000000000000", 18)
- *
- * @example
- * // Convert 1 BTC in satoshi (100000000) to normalized format
- * denoteAmount("100000000", 8)
- */
-export default function denoteAmount(amountAsString: string, decimals: number) {
-  if (decimals <= 9) return BigInt(amountAsString); // No conversion needed if decimals are 9 or less
-  const exponent = BigInt(decimals) - 9n;
-  const amount = BigInt(amountAsString);
-  return amount / 10n ** exponent; // Denote to 9 decimals
-}

package/src/payment/cryptopay/derive-btc-address.test.ts

@@ -1,22 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import deriveBtcAddress from './derive-btc-address.js';
-
-describe('BTC Address Derivation', () => {
-  it('returns a deterministic BIP44 child address', () => {
-    assert.equal(
-      deriveBtcAddress(
-        'zpub6qpRm6gMdkrXvVKw7qgayHnqJGJkpE4rnYQdyJfZW87ed4Fk6HjVaThN12hv2rrL3EzfvvBW6ZpbMEe5UxZYEjhgeMigyvAbS5LiXPkKrys',
-        1,
-      ),
-      'bc1qspcam3ntdpvhgz4vnxfdhas6qr8hf8tjfaz5p4',
-    );
-    assert.equal(
-      deriveBtcAddress(
-        'zpub6qpRm6gMdkrXvVKw7qgayHnqJGJkpE4rnYQdyJfZW87ed4Fk6HjVaThN12hv2rrL3EzfvvBW6ZpbMEe5UxZYEjhgeMigyvAbS5LiXPkKrys',
-        2,
-      ),
-      'bc1qd0a7znq3pz3sc4armthddkyam57ey7qjc4v6vn',
-    );
-  });
-});

package/src/payment/cryptopay/derive-btc-address.ts

@@ -1,46 +0,0 @@
-import { HDKey } from '@scure/bip32';
-import { NETWORK, p2wpkh, TEST_NETWORK } from '@scure/btc-signer';
-
-// 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 NETWORK;
-  return TEST_NETWORK;
-};
-
-export default (xpub, index) => {
-  const prefix = xpub.slice(0, 1);
-  if (prefix !== 'z' && prefix !== 'v')
-    throw new Error('Cryptopay only supports native segwit (zpub/vpub) extended key format for BTC');
-
-  const hardenedMaster = HDKey.fromExtendedKey(
-    xpub,
-    prefix === 'z'
-      ? {
-          public: 0x04b24746, // zpub public
-          private: 0x04b2430c, // zpriv private
-        }
-      : {
-          public: 0x045f1cf6,
-          private: 0x045f18bc,
-        },
-  );
-  hardenedMaster.wipePrivateData(); // Neuter
-
-  const child = hardenedMaster.deriveChild(0).deriveChild(index);
-
-  if (!child.publicKey) throw new Error('Cannot derive public key from extended public key');
-
-  const network = resolveNetwork(prefix);
-  const pubKey = p2wpkh(child.publicKey /* hex.decode( as string)*/, network);
-
-  return pubKey.address;
-};

package/src/payment/cryptopay/derive-eth-address.test.ts

@@ -1,22 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import deriveEthAddress from './derive-eth-address.js';
-
-describe('ETH Address Derivation', () => {
-  it('returns a deterministic BIP44 child address', () => {
-    assert.equal(
-      deriveEthAddress(
-        'xpub6DTksA6DsGUgbEp1U29v3qGTt5P99iKThaqGEzerTfD73ZAg1F8j15TxWTPEjjA1uw1Zmwwc5dgVCXwTL2ZNhvdoLWNdqVuL1MDJMsQCLLs',
-        1,
-      ),
-      '0x11CF7d607A1Dc45a002592891fF25DAAE6eC7dE9',
-    );
-    assert.equal(
-      deriveEthAddress(
-        'xpub6DTksA6DsGUgbEp1U29v3qGTt5P99iKThaqGEzerTfD73ZAg1F8j15TxWTPEjjA1uw1Zmwwc5dgVCXwTL2ZNhvdoLWNdqVuL1MDJMsQCLLs',
-        2,
-      ),
-      '0x61663D505e3aB5b61a5344eA2c64b644c08013ea',
-    );
-  });
-});

package/src/payment/cryptopay/derive-eth-address.ts

@@ -1,40 +0,0 @@
-import { HDKey } from '@scure/bip32';
-import { keccak_256 } from '@noble/hashes/sha3.js';
-import { secp256k1 } from '@noble/curves/secp256k1.js';
-
-function getChecksumAddress(address) {
-  const chars = address.split('');
-  const expanded = new Uint8Array(40);
-  for (let i = 0; i < 40; i++) {
-    expanded[i] = chars[i].charCodeAt(0);
-  }
-  const hashed = keccak_256(expanded);
-
-  for (let i = 0; i < 40; i += 2) {
-    if (hashed[i >> 1] >> 4 >= 8) {
-      chars[i] = chars[i].toUpperCase();
-    }
-    if ((hashed[i >> 1] & 0x0f) >= 8) {
-      chars[i + 1] = chars[i + 1].toUpperCase();
-    }
-  }
-
-  return '0x' + chars.join('');
-}
-
-export default (xpub, index) => {
-  const hardenedMaster = HDKey.fromExtendedKey(xpub);
-  hardenedMaster.wipePrivateData(); // Neuter
-
-  const child = hardenedMaster.deriveChild(0).deriveChild(index);
-
-  if (!child.publicKey) throw new Error('Could not derive child key from extended public key');
-
-  // ETH Address (secp256k1 + keccak_256 + checksum)
-  const childSigningKey = secp256k1.Point.fromBytes(child.publicKey).toBytes(false);
-  const address = Buffer.from(keccak_256(childSigningKey.slice(1)))
-    .toString('hex')
-    .substring(24);
-
-  return getChecksumAddress(address);
-};