refactor: payment network factory (#930)

Author: benjlevesque

packages/data-access/src/data-access.ts

@@ -57,8 +57,7 @@ const emptyChannelsWithTopics: DataAccessTypes.IReturnGetChannelsByTopic = {
  */
 export default class DataAccess implements DataAccessTypes.IDataAccess {
   // Transaction index, that allows storing and retrieving transactions by channel or topic, with time boundaries.
-  // public for test purpose
-  public transactionIndex: DataAccessTypes.ITransactionIndex;
+  private transactionIndex: DataAccessTypes.ITransactionIndex;
 
   // boolean to store the initialization state
   protected isInitialized = false;

packages/data-access/test/data-access.test.ts

@@ -4,6 +4,7 @@ import { DataAccessTypes, StorageTypes } from '@requestnetwork/types';
 
 import RequestDataAccessBlock from '../src/block';
 import DataAccess from '../src/data-access';
+import TransactionIndex from '../src/transaction-index';
 
 // We use this function to flush the call stack
 // If we don't use this function, the fake timer will be increased before the interval function being called
@@ -637,10 +638,10 @@ describe('data-access', () => {
       readMany: jest.fn(),
     };
 
-    const dataAccess = new DataAccess(fakeStorageWithNotJsonData);
+    const transactionIndex = new TransactionIndex();
+    const dataAccess = new DataAccess(fakeStorageWithNotJsonData, { transactionIndex });
+    const spy = jest.spyOn(transactionIndex, 'addTransaction').mockImplementation();
     await dataAccess.initialize();
-    const spy = jest.fn();
-    dataAccess.transactionIndex.addTransaction = spy;
     await dataAccess.synchronizeNewDataIds();
 
     expect(spy).not.toHaveBeenCalled();

packages/integration-test/test/node-client.test.ts

@@ -415,7 +415,7 @@ describe('Request client using a request node', () => {
 
     await fetchedRequest.refresh();
     expect(fetchedRequest.getData().expectedAmount).toBe('0');
-  });
+  }, 60000);
 
   it('create an encrypted and unencrypted request with the same content', async () => {
     const requestNetwork = new RequestNetwork({

packages/integration-test/test/scheduled/btc-test-data.ts

@@ -40,6 +40,7 @@ export const requestData = {
   currency: {
     type: RequestLogicTypes.CURRENCY.BTC,
     value: 'BTC',
+    network: 'mainnet',
   },
   expectedAmount: '100000000000',
   payee: payee.identity,

packages/integration-test/test/scheduled/escrow-detector.test.ts

@@ -1,4 +1,4 @@
-import { Erc20PaymentNetwork } from '../../../payment-detection/dist';
+import { Erc20PaymentNetwork } from '@requestnetwork/payment-detection';
 import { CurrencyManager } from '@requestnetwork/currency';
 import { createMockErc20FeeRequest } from '../utils';
 import { mockAdvancedLogic } from './mocks';

packages/integration-test/test/native-token.test.ts renamed to packages/integration-test/test/scheduled/native-token.test.ts

@@ -3,46 +3,41 @@ import { PaymentTypes, RequestLogicTypes } from '@requestnetwork/types';
 import { PnReferenceBased } from '@requestnetwork/types/dist/extension-types';
 import { AdvancedLogic } from '@requestnetwork/advanced-logic';
 import { CurrencyManager } from '@requestnetwork/currency';
+import { omit } from 'lodash';
 
 const advancedLogic = new AdvancedLogic();
-const currency = {
-  network: 'aurora-testnet',
-  type: RequestLogicTypes.CURRENCY.ETH,
-  value: 'NEAR',
-};
+
 const createCreationActionParams: PnReferenceBased.ICreationParameters = {
   paymentAddress: 'payment.testnet',
   salt: 'a1a2a3a4a5a6a7a8',
   paymentNetworkName: 'aurora-testnet',
 };
 
 describe('PaymentNetworkFactory and createExtensionsDataForCreation', () => {
+  const paymentNetworkFactory = new PaymentNetworkFactory(
+    advancedLogic,
+    CurrencyManager.getDefault(),
+  );
   it('PaymentNetworkFactory can createPaymentNetwork (mainnet)', async () => {
-    const paymentNetwork = PaymentNetworkFactory.createPaymentNetwork({
-      advancedLogic,
-      currency: { ...currency, network: 'aurora-testnet' },
-      paymentNetworkCreationParameters: {
-        id: PaymentTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN,
-        parameters: createCreationActionParams,
-      },
-      currencyManager: CurrencyManager.getDefault(),
-    });
+    const paymentNetwork = paymentNetworkFactory.createPaymentNetwork(
+      PaymentTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN,
+      RequestLogicTypes.CURRENCY.ETH,
+      'aurora-testnet',
+    );
     const action = await paymentNetwork.createExtensionsDataForCreation(createCreationActionParams);
     expect(action.parameters.paymentAddress).toEqual('payment.testnet');
     expect(action.parameters.paymentNetworkName).toEqual('aurora-testnet');
   });
   it('throws without a payment network name', async () => {
-    const paymentNetwork = PaymentNetworkFactory.createPaymentNetwork({
-      advancedLogic,
-      currency: { ...currency, network: 'aurora-testnet' },
-      paymentNetworkCreationParameters: {
-        id: PaymentTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN,
-        parameters: { ...createCreationActionParams, paymentNetworkName: undefined },
-      },
-      currencyManager: CurrencyManager.getDefault(),
-    });
+    const paymentNetwork = paymentNetworkFactory.createPaymentNetwork(
+      PaymentTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN,
+      RequestLogicTypes.CURRENCY.ETH,
+      'aurora-testnet',
+    );
     await expect(async () => {
-      await paymentNetwork.createExtensionsDataForCreation(createCreationActionParams);
+      await paymentNetwork.createExtensionsDataForCreation(
+        omit(createCreationActionParams, 'paymentNetworkName'),
+      );
     }).rejects.toThrowError(
       'The network name is mandatory for the creation of the extension pn-native-token.',
     );

packages/payment-detection/src/index.ts

@@ -1,4 +1,4 @@
-import PaymentNetworkFactory from './payment-network-factory';
+import { PaymentNetworkFactory, PaymentNetworkOptions } from './payment-network-factory';
 import PaymentReferenceCalculator from './payment-reference-calculator';
 
 import * as BtcPaymentNetwork from './btc';
@@ -26,6 +26,7 @@ export type { TheGraphClient } from './thegraph';
 
 export {
   PaymentNetworkFactory,
+  PaymentNetworkOptions,
   PaymentReferenceCalculator,
   BtcPaymentNetwork,
   DeclarativePaymentDetector,

packages/payment-detection/src/payment-network-factory.ts

@@ -1,9 +1,4 @@
-import {
-  AdvancedLogicTypes,
-  ExtensionTypes,
-  PaymentTypes,
-  RequestLogicTypes,
-} from '@requestnetwork/types';
+import { AdvancedLogicTypes, PaymentTypes, RequestLogicTypes } from '@requestnetwork/types';
 import { ICurrencyManager } from '@requestnetwork/currency';
 import { IPaymentNetworkModuleByType, ISupportedPaymentNetworkByCurrency } from './types';
 import { BtcMainnetAddressBasedDetector } from './btc/mainnet-address-based';
@@ -18,6 +13,7 @@ import { EthFeeProxyPaymentDetector } from './eth/fee-proxy-detector';
 import { AnyToERC20PaymentDetector } from './any/any-to-erc20-proxy';
 import { NearConversionNativeTokenPaymentDetector, NearNativeTokenPaymentDetector } from './near';
 import { AnyToEthFeeProxyPaymentDetector } from './any/any-to-eth-proxy';
+import { getPaymentNetworkExtension } from './utils';
 
 const PN_ID = PaymentTypes.PAYMENT_NETWORK_ID;
 
@@ -62,133 +58,84 @@ const anyCurrencyPaymentNetwork: IPaymentNetworkModuleByType = {
   [PN_ID.ANY_TO_NATIVE]: NearConversionNativeTokenPaymentDetector,
 };
 
+export type PaymentNetworkOptions = {
+  /** override default bitcoin detection provider */
+  bitcoinDetectionProvider?: PaymentTypes.IBitcoinDetectionProvider;
+  /** the explorer API (eg Etherscan) api keys, for PNs that rely on it. Record by network name  */
+  explorerApiKeys?: Record<string, string>;
+};
+
 /** Factory to create the payment network according to the currency and payment network type */
-export default class PaymentNetworkFactory {
+export class PaymentNetworkFactory {
+  /**
+   *
+   * @param advancedLogic the advanced-logic layer in charge of the extensions
+   * @param currencyManager the currency manager handling supported currencies
+   * @param options the payment network options
+   */
+  constructor(
+    private readonly advancedLogic: AdvancedLogicTypes.IAdvancedLogic,
+    private readonly currencyManager: ICurrencyManager,
+    private readonly options?: PaymentNetworkOptions,
+  ) {}
+
   /**
    * Creates a payment network according to payment network creation parameters
    * It throws if the payment network given is not supported by this library
    *
-   * @param advancedLogic the advanced-logic layer in charge of the extensions
    * @param currency the currency of the request
    * @param paymentNetworkCreationParameters creation parameters of payment network
-   * @param bitcoinDetectionProvider bitcoin detection provider
-   * @param currencyManager the currency manager handling supported currencies
    * @returns the module to handle the payment network
    */
-  public static createPaymentNetwork({
-    advancedLogic,
-    currency,
-    paymentNetworkCreationParameters,
-    bitcoinDetectionProvider,
-    currencyManager,
-  }: {
-    advancedLogic: AdvancedLogicTypes.IAdvancedLogic;
-    currency: RequestLogicTypes.ICurrency;
-    paymentNetworkCreationParameters: PaymentTypes.IPaymentNetworkCreateParameters;
-    bitcoinDetectionProvider?: PaymentTypes.IBitcoinDetectionProvider;
-    currencyManager: ICurrencyManager;
-  }): PaymentTypes.IPaymentNetwork {
-    const paymentNetworkForCurrency = this.supportedPaymentNetworksForCurrency(currency);
+  public createPaymentNetwork(
+    paymentNetworkId: PaymentTypes.PAYMENT_NETWORK_ID,
+    currencyType: RequestLogicTypes.CURRENCY,
+    currencyNetwork?: string,
+  ): PaymentTypes.IPaymentNetwork {
+    const currencyPaymentMap =
+      supportedPaymentNetwork[currencyType]?.[currencyNetwork || 'mainnet'] ||
+      supportedPaymentNetwork[currencyType]?.['*'] ||
+      {};
+    const paymentNetworkMap = {
+      ...currencyPaymentMap,
+      ...anyCurrencyPaymentNetwork,
+    };
 
-    if (!paymentNetworkForCurrency[paymentNetworkCreationParameters.id]) {
+    if (!paymentNetworkMap[paymentNetworkId]) {
       throw new Error(
-        `the payment network id: ${
-          paymentNetworkCreationParameters.id
-        } is not supported for the currency: ${currency.type} on network ${
-          currency.network || 'mainnet'
+        `the payment network id: ${paymentNetworkId} is not supported for the currency: ${currencyType} on network ${
+          currencyNetwork || 'mainnet'
         }`,
       );
     }
-
-    return new paymentNetworkForCurrency[paymentNetworkCreationParameters.id]({
-      advancedLogic,
-      bitcoinDetectionProvider,
-      currencyManager,
+    return new paymentNetworkMap[paymentNetworkId]({
+      advancedLogic: this.advancedLogic,
+      currencyManager: this.currencyManager,
+      ...this.options,
     });
   }
 
   /**
    * Gets the module to the payment network of a request
    * It throws if the payment network found is not supported by this library
    *
-   * @param advancedLogic the advanced-logic layer in charge of the extensions
    * @param request the request
-   * @param bitcoinDetectionProvider bitcoin detection provider
-   * @param explorerApiKeys the explorer API (eg Etherscan) api keys, for PNs that rely on it. Record by network name.
-   * @param currencyManager the currency manager handling supported currencies
    * @returns the module to handle the payment network or null if no payment network found
    */
-  public static getPaymentNetworkFromRequest({
-    advancedLogic,
-    request,
-    bitcoinDetectionProvider,
-    explorerApiKeys,
-    currencyManager,
-  }: {
-    advancedLogic: AdvancedLogicTypes.IAdvancedLogic;
-    request: RequestLogicTypes.IRequest;
-    currencyManager: ICurrencyManager;
-    bitcoinDetectionProvider?: PaymentTypes.IBitcoinDetectionProvider;
-    explorerApiKeys?: Record<string, string>;
-  }): PaymentTypes.IPaymentNetwork | null {
-    const currency = request.currency;
-    const extensionPaymentNetwork = Object.values(request.extensions || {}).find(
-      (extension) => extension.type === ExtensionTypes.TYPE.PAYMENT_NETWORK,
-    );
+  public getPaymentNetworkFromRequest(
+    request: RequestLogicTypes.IRequest,
+  ): PaymentTypes.IPaymentNetwork | null {
+    const pn = getPaymentNetworkExtension(request);
 
-    if (!extensionPaymentNetwork) {
+    if (!pn) {
       return null;
     }
 
-    const paymentNetworkId = extensionPaymentNetwork.id;
-    const paymentNetworkForCurrency = this.supportedPaymentNetworksForCurrency(currency);
-
-    if (!paymentNetworkForCurrency[paymentNetworkId]) {
-      throw new Error(
-        `the payment network id: ${paymentNetworkId} is not supported for the currency: ${
-          currency.type
-        } on network ${currency.network || 'mainnet'}`,
-      );
-    }
-
-    return new paymentNetworkForCurrency[paymentNetworkId]({
-      advancedLogic,
-      bitcoinDetectionProvider,
-      explorerApiKeys,
-      currencyManager,
-    });
-  }
-
-  /**
-   * Gets the payment networks supported for a Currency object
-   *
-   * @param currency The currency to get the supported networks for
-   */
-  public static supportedPaymentNetworksForCurrency(
-    currency: RequestLogicTypes.ICurrency,
-  ): IPaymentNetworkModuleByType {
-    if (!supportedPaymentNetwork[currency.type]) {
-      return anyCurrencyPaymentNetwork;
-    }
-
-    const paymentNetwork =
-      supportedPaymentNetwork[currency.type][currency.network || 'mainnet'] ||
-      supportedPaymentNetwork[currency.type]['*'];
-
-    return { ...paymentNetwork, ...anyCurrencyPaymentNetwork };
-  }
-
-  /**
-   * Checks if a networkId is part of the supported networks for given currency
-   *
-   * @param paymentNetworkId The networkId to check is supported by this currency
-   * @param currency The currency to check the supported networks for
-   */
-  public static currencySupportsPaymentNetwork(
-    paymentNetworkId: PaymentTypes.PAYMENT_NETWORK_ID,
-    currency: RequestLogicTypes.ICurrency,
-  ): boolean {
-    const paymentNetworks = this.supportedPaymentNetworksForCurrency(currency);
-    return !!paymentNetworks[paymentNetworkId];
+    const paymentNetworkId = pn.id as unknown as PaymentTypes.PAYMENT_NETWORK_ID;
+    return this.createPaymentNetwork(
+      paymentNetworkId,
+      request.currency.type,
+      request.currency.network,
+    );
   }
 }

packages/payment-detection/test/near/near-native-conversion.test.ts

@@ -5,7 +5,7 @@ import {
   RequestLogicTypes,
 } from '@requestnetwork/types';
 import { CurrencyDefinition, CurrencyManager } from '@requestnetwork/currency';
-import PaymentNetworkFactory from '../../src/payment-network-factory';
+import { PaymentNetworkFactory } from '../../src/payment-network-factory';
 import PaymentReferenceCalculator from '../../src/payment-reference-calculator';
 import {
   NearConversionNativeTokenPaymentDetector,
@@ -75,6 +75,7 @@ const graphPaymentEvent = {
   gasPrice: '2425000017',
 };
 
+const paymentNetworkFactory = new PaymentNetworkFactory(mockAdvancedLogic, currencyManager);
 describe('Near payments detection', () => {
   beforeAll(() => {
     graphql.request.mockResolvedValue({
@@ -121,21 +122,16 @@ describe('Near payments detection', () => {
   });
 
   it('PaymentNetworkFactory can get the detector (testnet)', async () => {
-    expect(
-      PaymentNetworkFactory.getPaymentNetworkFromRequest({
-        advancedLogic: mockAdvancedLogic,
-        request,
-        currencyManager,
-      }),
-    ).toBeInstanceOf(NearConversionNativeTokenPaymentDetector);
+    expect(paymentNetworkFactory.getPaymentNetworkFromRequest(request)).toBeInstanceOf(
+      NearConversionNativeTokenPaymentDetector,
+    );
   });
 
   it('PaymentNetworkFactory can get the detector (mainnet)', async () => {
     expect(
-      PaymentNetworkFactory.getPaymentNetworkFromRequest({
-        advancedLogic: mockAdvancedLogic,
-        request: { ...request, currency: { ...request.currency, network: 'aurora' } },
-        currencyManager,
+      paymentNetworkFactory.getPaymentNetworkFromRequest({
+        ...request,
+        currency: { ...request.currency, network: 'aurora' },
       }),
     ).toBeInstanceOf(NearConversionNativeTokenPaymentDetector);
   });