@unchainedshop/plugins 3.1.14 → 4.0.0-rc.10

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

@@ -5,7 +5,7 @@ import { fixPeriods } from './fix-periods.js';
 import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 import { AppleTransactionsModule } from './module.js';
 
-const logger = createLogger('unchained:core-payment:iap');
+const logger = createLogger('unchained:core-payment:apple-iap:handler');
 
 const { APPLE_IAP_SHARED_SECRET } = process.env;
 
@@ -33,7 +33,7 @@ export const appleIAPHandler: RouteHandlerMethod = async (
       throw new Error('shared secret not valid');
     }
 
-      const transactions = responseBody?.unified_receipt?.latest_receipt_info; // eslint-disable-line
+    const transactions = responseBody?.unified_receipt?.latest_receipt_info;
     const latestTransaction = transactions[0];
 
     if (responseBody.notification_type === AppleNotificationTypes.INITIAL_BUY) {
@@ -48,7 +48,7 @@ export const appleIAPHandler: RouteHandlerMethod = async (
 
       const order = await services.orders.checkoutOrder(orderPayment.orderId, {
         paymentContext: {
-                receiptData: responseBody?.unified_receipt?.latest_receipt, // eslint-disable-line
+          receiptData: responseBody?.unified_receipt?.latest_receipt,
         },
       });
       const orderId = order._id;
@@ -86,7 +86,7 @@ export const appleIAPHandler: RouteHandlerMethod = async (
 
       await services.orders.registerPaymentCredentials(enrollment.payment.paymentProviderId, {
         transactionContext: {
-              receiptData: responseBody?.unified_receipt?.latest_receipt, // eslint-disable-line
+          receiptData: responseBody?.unified_receipt?.latest_receipt,
         },
         userId: enrollment.userId,
       });

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

@@ -24,6 +24,6 @@ export default {
   },
 };
 
-export type AppleTransactionsModule = {
+export interface AppleTransactionsModule {
   appleTransactions: Awaited<ReturnType<typeof configureAppleTransactionsModule>>;
-};
+}

package/src/payment/braintree.ts

@@ -52,7 +52,6 @@ const BraintreeDirect: IPaymentAdapter = {
       return BRAINTREE_SANDBOX_TOKEN;
     };
 
-    // eslint-disable-next-line
     const getPrivateKey = () => {
       return BRAINTREE_PRIVATE_KEY;
     };
@@ -114,17 +113,17 @@ const BraintreeDirect: IPaymentAdapter = {
 
         // eslint-disable-next-line
         // @ts-ignore
-        const braintree = (await import('braintree')).default; // eslint-disable-line
+        const braintree = (await import('braintree')).default;
         const gateway = getGateway(braintree);
         const address = order.billingAddress;
         const pricing = OrderPricingSheet({
           calculation: order.calculation,
-          currency: order.currency,
+          currencyCode: order.currencyCode,
         });
         const rounded = Math.round(pricing.total({ useNetPrice: false }).amount / 10 || 0) * 10;
         const saleRequest = {
           amount: rounded / 100,
-          merchantAccountId: order.currency,
+          merchantAccountId: order.currencyCode,
           paymentMethodNonce: paypalPaymentMethodNonce,
           orderId: order.orderNumber || order._id,
           shipping: address

package/src/payment/cryptopay/db/CryptopayTransactions.ts

@@ -6,9 +6,8 @@ export type CryptopayTransaction = {
   blockHeight: number;
   mostRecentBlockHeight: number;
   amount: mongodb.Decimal128;
-  currency: string;
+  currencyCode: string;
   decimals: number;
-  contract: string;
   orderPaymentId?: string;
 } & TimestampFields;
 

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

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

@@ -0,0 +1,29 @@
+/**
+ * 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

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

@@ -0,0 +1,48 @@
+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);
+
+  // We don't need this AFAIK:
+  // const derivationPath = resolvePath(prefix);
+  // const child = hardenedMaster.derive(`${derivationPath}/0/${btcDerivationNumber}`);
+
+  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

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

@@ -0,0 +1,38 @@
+import { HDKey } from '@scure/bip32';
+import { keccak_256 } from '@noble/hashes/sha3';
+import { secp256k1 } from '@noble/curves/secp256k1';
+
+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);
+
+  // ETH Address (secp256k1 + keccak_256 + checksum)
+  const childSigningKey = secp256k1.ProjectivePoint.fromHex(child.publicKey).toRawBytes(false);
+  const address = Buffer.from(keccak_256(childSigningKey.slice(1)))
+    .toString('hex')
+    .substring(24);
+
+  return getChecksumAddress(address);
+};

package/src/payment/cryptopay/handle-webhook.ts

@@ -0,0 +1,103 @@
+import { createLogger } from '@unchainedshop/logger';
+import { Context } from '@unchainedshop/api';
+import { OrderStatus } from '@unchainedshop/core-orders';
+import { CryptopayModule } from './module.js';
+import { ProductPriceRate } from '@unchainedshop/core-products';
+
+const { CRYPTOPAY_SECRET, CRYPTOPAY_MAX_RATE_AGE = '360' } = process.env;
+
+const logger = createLogger('unchained:core-payment:cryptopay:handler');
+
+export default async function handleWebhook(
+  {
+    secret,
+    wallet,
+    price,
+    ping,
+  }: {
+    secret: string;
+    wallet?: {
+      address: string;
+      blockHeight: number;
+      amount: string;
+      contract?: string;
+      decimals?: number;
+      currencyCode: string;
+    };
+    price?: {
+      baseCurrency: string;
+      token: string;
+      rate: number;
+      timestamp: string; // ISO date string
+    };
+    ping?: {
+      blockHeight: number;
+      currencyCode: string;
+    };
+  },
+  context: Context & {
+    modules: CryptopayModule;
+  },
+) {
+  const { modules, services } = context;
+
+  if (secret !== CRYPTOPAY_SECRET) {
+    logger.warn(`webhook called with invalid secret`);
+    throw new Error('Secret invalid');
+  }
+
+  if (wallet) {
+    const { address, blockHeight, amount, contract, decimals, currencyCode } = wallet;
+    logger.debug('webhook received wallet data', wallet);
+    const { orderPaymentId } = await modules.cryptopay.updateWalletAddress({
+      address,
+      blockHeight,
+      amount,
+      contract,
+      decimals,
+      currencyCode,
+    });
+
+    const orderPayment =
+      orderPaymentId &&
+      (await modules.orders.payments.findOrderPayment({
+        orderPaymentId,
+      }));
+
+    if (orderPayment) {
+      // Try to process order to next status
+      // TODO: Not sure if it's correct to use processOrder here if status is PENDING!
+      const order = await modules.orders.findOrder({ orderId: orderPayment.orderId });
+      if (order.status === null) {
+        await services.orders.checkoutOrder(order._id, {});
+      } else if (order.status === OrderStatus.PENDING) {
+        await services.orders.processOrder(order, {});
+      } else {
+        throw new Error('Already processed');
+      }
+    }
+  }
+
+  if (price) {
+    logger.debug('webhook received price data', price);
+    const { baseCurrency, token, rate, timestamp } = price;
+
+    const timestampDate = new Date(timestamp);
+    const expiresAt = new Date(new Date().getTime() + parseInt(CRYPTOPAY_MAX_RATE_AGE, 10) * 1000);
+
+    const rateData: ProductPriceRate = {
+      baseCurrency,
+      quoteCurrency: token,
+      rate,
+      expiresAt,
+      timestamp: timestampDate,
+    };
+    await modules.products.prices.rates.updateRates([rateData]);
+  }
+
+  if (ping) {
+    logger.debug('webhook received ping data', ping);
+    const { blockHeight, currencyCode } = ping;
+    await modules.cryptopay.updateMostRecentBlock(currencyCode, blockHeight);
+  }
+}

package/src/payment/cryptopay/handler-express.ts

@@ -1,83 +1,17 @@
 import { createLogger } from '@unchainedshop/logger';
-import { Context } from '@unchainedshop/api';
-import { OrderStatus } from '@unchainedshop/core-orders';
-import { CryptopayModule } from './module.js';
-import { ProductPriceRate } from '@unchainedshop/core-products';
+import handleWebhook from './handle-webhook.js';
 
-const { CRYPTOPAY_SECRET, CRYPTOPAY_MAX_RATE_AGE = '360' } = process.env;
-
-const logger = createLogger('unchained:core-payment:cryptopay');
+const logger = createLogger('unchained:core-payment:cryptopay:handler');
 
 const cryptopayHandler = async (req, res) => {
-  const resolvedContext = req.unchainedContext as Context & {
-    modules: CryptopayModule;
-  };
-  const { modules, services } = resolvedContext;
-
   if (req.method === 'POST') {
     try {
-      const { secret, price, wallet, ping } = req.body;
-      if (secret !== CRYPTOPAY_SECRET) {
-        logger.warn(`Cryptopay Plugin: Invalid Cryptopay Secret provided`);
-        throw new Error('Secret invalid');
-      }
-
-      if (wallet) {
-        const { address, blockHeight, amount, contract, decimals, currency } = wallet;
-        const { orderPaymentId } = await modules.cryptopay.updateWalletAddress({
-          addressId: address,
-          blockHeight,
-          amount,
-          contract,
-          decimals,
-          currency,
-        });
-        const orderPayment =
-          orderPaymentId &&
-          (await modules.orders.payments.findOrderPayment({
-            orderPaymentId,
-          }));
-
-        if (orderPayment) {
-          // Try to process order to next status
-          // TODO: Not sure if it's correct to use processOrder here if status is PENDING!
-          const order = await modules.orders.findOrder({ orderId: orderPayment.orderId });
-          if (order.status === null) {
-            await services.orders.checkoutOrder(order._id, {});
-          } else if (order.status === OrderStatus.PENDING) {
-            await services.orders.processOrder(order, {});
-          } else {
-            throw new Error('Already processed');
-          }
-        }
-      }
-
-      if (price) {
-        const { baseCurrency, token, rate, timestamp } = price;
-
-        const timestampDate = new Date(timestamp);
-        const expiresAt = new Date(new Date().getTime() + parseInt(CRYPTOPAY_MAX_RATE_AGE, 10) * 1000);
-
-        const rateData: ProductPriceRate = {
-          baseCurrency,
-          quoteCurrency: token,
-          rate,
-          expiresAt,
-          timestamp: timestampDate,
-        };
-        logger.info(`update rate ${JSON.stringify(price)}, ${JSON.stringify(rateData)}`);
-        await resolvedContext.modules.products.prices.rates.updateRates([rateData]);
-      }
-
-      if (ping) {
-        const { blockHeight, currency } = ping;
-        await modules.cryptopay.updateMostRecentBlock(currency, blockHeight);
-      }
-
+      await handleWebhook(req.body, req.unchainedContext);
       res.writeHead(200);
       res.end(JSON.stringify({ success: true }));
       return;
     } catch (e) {
+      logger.error(e);
       res.writeHead(500);
       res.end(JSON.stringify({ success: false, error: e.message }));
       return;

package/src/payment/cryptopay/handler-fastify.ts

@@ -1,86 +1,21 @@
-import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 import { createLogger } from '@unchainedshop/logger';
-import { Context } from '@unchainedshop/api';
-import { OrderStatus } from '@unchainedshop/core-orders';
-import { CryptopayModule } from './module.js';
-import { ProductPriceRate } from '@unchainedshop/core-products';
-
-const { CRYPTOPAY_SECRET, CRYPTOPAY_MAX_RATE_AGE = '360' } = process.env;
+import handleWebhook from './handle-webhook.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 
-const logger = createLogger('unchained:core-payment:cryptopay');
+const logger = createLogger('unchained:core-payment:cryptopay:handler');
 
 const cryptopayHandler: RouteHandlerMethod = async (
   req: FastifyRequest & {
-    unchainedContext: Context & {
-      modules: CryptopayModule;
-    };
+    unchainedContext: any;
   },
   reply,
 ) => {
-  const { modules, services } = req.unchainedContext;
-
   try {
-    const { secret, price, wallet, ping } = req.body as Record<string, any>;
-    if (secret !== CRYPTOPAY_SECRET) {
-      logger.warn(`Cryptopay Plugin: Invalid Cryptopay Secret provided`);
-      throw new Error('Secret invalid');
-    }
-
-    if (wallet) {
-      const { address, blockHeight, amount, contract, decimals, currency } = wallet;
-      const { orderPaymentId } = await modules.cryptopay.updateWalletAddress({
-        addressId: address,
-        blockHeight,
-        amount,
-        contract,
-        decimals,
-        currency,
-      });
-      const orderPayment =
-        orderPaymentId &&
-        (await modules.orders.payments.findOrderPayment({
-          orderPaymentId,
-        }));
-
-      if (orderPayment) {
-        // Try to process order to next status
-        // TODO: Not sure if it's correct to use processOrder here if status is PENDING!
-        const order = await modules.orders.findOrder({ orderId: orderPayment.orderId });
-        if (order.status === null) {
-          await services.orders.checkoutOrder(order._id, {});
-        } else if (order.status === OrderStatus.PENDING) {
-          await services.orders.processOrder(order, {});
-        } else {
-          throw new Error('Already processed');
-        }
-      }
-    }
-
-    if (price) {
-      const { baseCurrency, token, rate, timestamp } = price;
-
-      const timestampDate = new Date(timestamp);
-      const expiresAt = new Date(new Date().getTime() + parseInt(CRYPTOPAY_MAX_RATE_AGE, 10) * 1000);
-
-      const rateData: ProductPriceRate = {
-        baseCurrency,
-        quoteCurrency: token,
-        rate,
-        expiresAt,
-        timestamp: timestampDate,
-      };
-      logger.info(`update rate ${JSON.stringify(price)}, ${JSON.stringify(rateData)}`);
-      await modules.products.prices.rates.updateRates([rateData]);
-    }
-
-    if (ping) {
-      const { blockHeight, currency } = ping;
-      await modules.cryptopay.updateMostRecentBlock(currency, blockHeight);
-    }
-
+    await handleWebhook(req.body as any, 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 });
   }