refactor: chain manager WIP

.circleci/config.yml

@@ -81,6 +81,9 @@ jobs:
       - run:
           name: Build utils
           command: yarn workspace @requestnetwork/utils run build
+      - run:
+          name: Build chain
+          command: yarn workspace @requestnetwork/chain run build
       - run:
           name: Build currency
           command: yarn workspace @requestnetwork/currency run build
@@ -284,6 +287,18 @@ jobs:
           command: 'yarn workspace @requestnetwork/utils run test --ci --maxWorkers=1'
       - store_test_results:
           path: packages/utils/reports/
+  test-chain:
+    docker:
+      - *node_image
+    working_directory: *working_directory
+    steps:
+      - attach_workspace:
+          at: *working_directory
+      - run:
+          name: 'Test chain'
+          command: 'yarn workspace @requestnetwork/chain run test --ci --maxWorkers=1'
+      - store_test_results:
+          path: packages/chain/reports/
   test-currency:
     docker:
       - *node_image
@@ -555,6 +570,9 @@ workflows:
       - test-utils:
           requires:
             - build
+      - test-chain:
+          requires:
+            - build
       - test-currency:
           requires:
             - build
@@ -588,6 +606,7 @@ workflows:
           requires:
             - lint
             - test-advanced-logic
+            - test-chain
             - test-currency
             - test-data-access
             - test-data-format

packages/advanced-logic/src/advanced-logic.ts

@@ -1,11 +1,11 @@
 import {
   AdvancedLogicTypes,
-  CurrencyTypes,
+  ChainTypes,
   ExtensionTypes,
   IdentityTypes,
   RequestLogicTypes,
 } from '@requestnetwork/types';
-import { ICurrencyManager, NearChains, isSameChain } from '@requestnetwork/currency';
+import { ICurrencyManager } from '@requestnetwork/currency';
 
 import ContentData from './extensions/content-data';
 import AddressBasedBtc from './extensions/payment-network/bitcoin/mainnet-address-based';
@@ -27,11 +27,34 @@ import NativeToken from './extensions/payment-network/native-token';
 import AnyToNative from './extensions/payment-network/any-to-native';
 import Erc20TransferableReceivablePaymentNetwork from './extensions/payment-network/erc20/transferable-receivable';
 
+const { ECOSYSTEM, VM_ECOSYSTEMS } = ChainTypes;
+
 /**
  * Module to manage Advanced logic extensions
  * Package to route the format and parsing of extensions following their id
  */
 export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic {
+  public static supportedEcosystemsForExtension: Record<
+    ExtensionTypes.ID,
+    readonly ChainTypes.ECOSYSTEM[]
+  > = {
+    [ExtensionTypes.ID.CONTENT_DATA]: [ECOSYSTEM.EVM],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.BITCOIN_ADDRESS_BASED]: [ECOSYSTEM.BTC],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.TESTNET_BITCOIN_ADDRESS_BASED]: [ECOSYSTEM.BTC],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_DECLARATIVE]: [ECOSYSTEM.BTC],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_ADDRESS_BASED]: VM_ECOSYSTEMS,
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_PROXY_CONTRACT]: VM_ECOSYSTEMS,
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT]: VM_ECOSYSTEMS,
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ERC777_STREAM]: [ECOSYSTEM.EVM],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ETH_INPUT_DATA]: [ECOSYSTEM.EVM],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN]: [ECOSYSTEM.NEAR],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_ERC20_PROXY]: VM_ECOSYSTEMS,
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ETH_FEE_PROXY_CONTRACT]: [ECOSYSTEM.EVM],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_ETH_PROXY]: [ECOSYSTEM.EVM],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_NATIVE_TOKEN]: [ECOSYSTEM.NEAR],
+    [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_TRANSFERABLE_RECEIVABLE]: [ECOSYSTEM.EVM],
+  };
+
   /** Give access to the functions specific of the extensions supported */
   public extensions: {
     addressBasedBtc: AddressBasedBtc;
@@ -108,8 +131,23 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
     requestState: RequestLogicTypes.IRequest,
   ): ExtensionTypes.IExtension {
     const id: ExtensionTypes.ID = extensionAction.id;
-    const network = this.getNetwork(extensionAction, requestState) || requestState.currency.network;
-    const extension: ExtensionTypes.IExtension | undefined = {
+    const ecosystems = AdvancedLogic.supportedEcosystemsForExtension[id];
+    if (!ecosystems) {
+      throw Error(`chain ecosystem not recognized for extension: ${id}`);
+    }
+    const chain = this.getChainForActionAndState(extensionAction, requestState, ecosystems);
+    const extensions = this.getExtensionsForChain(chain);
+    const extension = extensions[id];
+    if (!extension) {
+      throw Error(`extension with id: ${id} not found for network: ${chain}`);
+    }
+    return extension;
+  }
+
+  public getExtensionsForChain(
+    chain?: ChainTypes.IChain,
+  ): Record<ExtensionTypes.ID, ExtensionTypes.IExtension | undefined> {
+    const extensions: Record<ExtensionTypes.ID, ExtensionTypes.IExtension | undefined> = {
       [ExtensionTypes.ID.CONTENT_DATA]: this.extensions.contentData,
       [ExtensionTypes.PAYMENT_NETWORK_ID.BITCOIN_ADDRESS_BASED]: this.extensions.addressBasedBtc,
       [ExtensionTypes.PAYMENT_NETWORK_ID.TESTNET_BITCOIN_ADDRESS_BASED]:
@@ -118,36 +156,36 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_ADDRESS_BASED]: this.extensions.addressBasedErc20,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_PROXY_CONTRACT]: this.extensions.proxyContractErc20,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT]:
-        this.getFeeProxyContractErc20ForNetwork(network),
+        this.getFeeProxyContractErc20ForNetwork(chain),
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC777_STREAM]: this.extensions.erc777Stream,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ETH_INPUT_DATA]: this.extensions.ethereumInputData,
       [ExtensionTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN]:
-        this.getNativeTokenExtensionForNetwork(network),
+        this.getNativeTokenExtensionForNetwork(chain),
       [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_ERC20_PROXY]: this.extensions.anyToErc20Proxy,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ETH_FEE_PROXY_CONTRACT]:
         this.extensions.feeProxyContractEth,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_ETH_PROXY]: this.extensions.anyToEthProxy,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_NATIVE_TOKEN]:
-        this.getAnyToNativeTokenExtensionForNetwork(network),
+        this.getAnyToNativeTokenExtensionForNetwork(chain),
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_TRANSFERABLE_RECEIVABLE]:
         this.extensions.erc20TransferableReceivable,
-    }[id];
-
-    if (!extension) {
-      if (
-        id === ExtensionTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN ||
-        id === ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_NATIVE_TOKEN
-      ) {
-        throw Error(`extension with id: ${id} not found for network: ${network}`);
-      }
-
-      throw Error(`extension not recognized, id: ${id}`);
-    }
-    return extension;
+    };
+    // filter-out unsupported extensions for this chain ecosystem
+    return (Object.keys(extensions) as ExtensionTypes.ID[]).reduce(
+      (filteredExtensions, extensionId) => {
+        filteredExtensions[extensionId] =
+          chain &&
+          AdvancedLogic.supportedEcosystemsForExtension[extensionId].includes(chain.ecosystem)
+            ? extensions[extensionId]
+            : undefined;
+        return filteredExtensions;
+      },
+      {} as Record<ExtensionTypes.ID, ExtensionTypes.IExtension | undefined>,
+    );
   }
 
   public getNativeTokenExtensionForNetwork(
-    network?: CurrencyTypes.ChainName,
+    network?: ChainTypes.IChain,
   ): ExtensionTypes.IExtension<ExtensionTypes.PnReferenceBased.ICreationParameters> | undefined {
     return network
       ? this.extensions.nativeToken.find((nativeTokenExtension) =>
@@ -157,7 +195,7 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
   }
 
   public getAnyToNativeTokenExtensionForNetwork(
-    network?: CurrencyTypes.ChainName,
+    network?: ChainTypes.IChain,
   ): AnyToNative | undefined {
     return network
       ? this.extensions.anyToNativeToken.find((anyToNativeTokenExtension) =>
@@ -166,30 +204,46 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
       : undefined;
   }
 
-  public getFeeProxyContractErc20ForNetwork(network?: string): FeeProxyContractErc20 {
-    return NearChains.isChainSupported(network)
+  public getFeeProxyContractErc20ForNetwork(network?: ChainTypes.IChain): FeeProxyContractErc20 {
+    return this.currencyManager.chainManager.ecosystems[ECOSYSTEM.NEAR].isChainSupported(network)
       ? new FeeProxyContractErc20(this.currencyManager, undefined, undefined, network)
       : this.extensions.feeProxyContractErc20;
   }
 
-  protected getNetwork(
+  private getChainForActionAndState(
     extensionAction: ExtensionTypes.IAction,
     requestState: RequestLogicTypes.IRequest,
-  ): CurrencyTypes.ChainName | undefined {
+    ecosystems: readonly ChainTypes.ECOSYSTEM[],
+  ): ChainTypes.IChain | undefined {
+    // This check is only used for the "native-token" extension
+    // (notice the "extensionAction.parameters.paymentNetworkName" property).
+    // This is important because "isSameChain" throws an error
+    // when "extensionAction.parameters.paymentNetworkName"
+    // and the chain supporting "requestState.currency"
+    // are not part of the same ecosystem.
+    // This should not happen in this case.
     if (
       requestState.currency.network &&
       extensionAction.parameters.paymentNetworkName &&
-      !isSameChain(requestState.currency.network, extensionAction.parameters.paymentNetworkName)
+      !this.currencyManager.chainManager.isSameChain(
+        requestState.currency.network,
+        extensionAction.parameters.paymentNetworkName,
+        ecosystems,
+      )
     ) {
       throw new Error(
-        `Cannot apply action for network ${extensionAction.parameters.paymentNetworkName} on state with payment network: ${requestState.currency.network}`,
+        `Cannot apply action for extension ${extensionAction.parameters.paymentNetworkName} on state with chain: ${requestState.currency.network}`,
       );
     }
-    const network =
-      extensionAction.action === 'create'
+
+    const chainName =
+      (extensionAction.action === 'create'
         ? extensionAction.parameters.network
         : requestState.extensions[ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_NATIVE_TOKEN]?.values
-            ?.network;
-    return network;
+            ?.network) || requestState.currency.network;
+
+    if (!chainName) return;
+
+    return this.currencyManager.chainManager.fromName(chainName, ecosystems);
   }
 }

packages/advanced-logic/src/extensions/abstract-extension.ts

@@ -1,11 +1,17 @@
-import { ExtensionTypes, IdentityTypes, RequestLogicTypes } from '@requestnetwork/types';
+import {
+  ChainTypes,
+  ExtensionTypes,
+  IdentityTypes,
+  RequestLogicTypes,
+} from '@requestnetwork/types';
 import { deepCopy } from '@requestnetwork/utils';
 
 /**
  * Abstract class to create extension
  */
 export abstract class AbstractExtension<TCreationParameters> implements ExtensionTypes.IExtension {
   protected actions: ExtensionTypes.SupportedActions;
+  static supportedEcosystems: ChainTypes.ECOSYSTEM[] = [ChainTypes.ECOSYSTEM.EVM];
 
   protected constructor(
     public readonly extensionType: ExtensionTypes.TYPE,

packages/advanced-logic/src/extensions/payment-network/address-based.ts

@@ -1,6 +1,6 @@
 import { ICurrencyManager, UnsupportedCurrencyError } from '@requestnetwork/currency';
 import {
-  CurrencyTypes,
+  ChainTypes,
   ExtensionTypes,
   IdentityTypes,
   RequestLogicTypes,
@@ -151,7 +151,11 @@ export default abstract class AddressBasedPaymentNetwork<
       case RequestLogicTypes.CURRENCY.ETH:
       case RequestLogicTypes.CURRENCY.ERC20:
       case RequestLogicTypes.CURRENCY.ERC777:
-        return this.isValidAddressForSymbolAndNetwork(address, 'ETH', 'mainnet');
+        return this.isValidAddressForSymbolAndNetwork(
+          address,
+          'ETH',
+          this.currencyManager.chainManager.fromName('mainnet', [ChainTypes.ECOSYSTEM.EVM]),
+        );
       default:
         throw new Error(
           `Default implementation of isValidAddressForNetwork() does not support currency type ${this.supportedCurrencyType}. Please override this method if needed.`,
@@ -162,11 +166,11 @@ export default abstract class AddressBasedPaymentNetwork<
   protected isValidAddressForSymbolAndNetwork(
     address: string,
     symbol: string,
-    network: CurrencyTypes.ChainName,
+    network: ChainTypes.IChain,
   ): boolean {
     const currency = this.currencyManager.from(symbol, network);
     if (!currency) {
-      throw new UnsupportedCurrencyError({ value: symbol, network });
+      throw new UnsupportedCurrencyError({ value: symbol, network: network.name });
     }
     return this.currencyManager.validateAddress(address, currency);
   }
@@ -276,10 +280,21 @@ export default abstract class AddressBasedPaymentNetwork<
     this.throwIfInvalidNetwork(request.currency.network);
   }
 
-  protected throwIfInvalidNetwork(network?: string): asserts network is string {
-    if (!network) {
+  protected throwIfInvalidNetwork(chain?: string | ChainTypes.IChain): ChainTypes.IChain {
+    if (!chain) {
       throw Error('network is required');
     }
+    const supportedEcosystems = this.currencyManager.chainManager.getEcosystemsByCurrencyType(
+      this.supportedCurrencyType,
+    );
+    if (typeof chain === 'string') {
+      // throws if network not found
+      return this.currencyManager.chainManager.fromName(chain, supportedEcosystems);
+    }
+    if (!supportedEcosystems.includes(chain.ecosystem)) {
+      throw Error(`Payment network ${this.constructor.name} does not support chain ${chain.name}`);
+    }
+    return chain;
   }
 }
 
@@ -291,12 +306,20 @@ export class InvalidPaymentAddressError extends Error {
 }
 
 export class UnsupportedNetworkError extends Error {
-  constructor(unsupportedNetworkName: string, supportedNetworks?: string[]) {
-    const supportedNetworkDetails = supportedNetworks
-      ? ` (only ${supportedNetworks.join(', ')})`
+  constructor(
+    extension: string,
+    unsupportedChain: string | ChainTypes.IChain,
+    supportedChains?: string[] | ChainTypes.IChain[],
+  ) {
+    const unsupportedChainName =
+      typeof unsupportedChain === 'string' ? unsupportedChain : unsupportedChain.name;
+    const supportedNetworkDetails = supportedChains
+      ? ` (only "${supportedChains
+          .map((chain) => (typeof chain === 'string' ? chain : chain.name))
+          .join(', ')}")`
       : '';
     super(
-      `Payment network '${unsupportedNetworkName}' is not supported by this extension${supportedNetworkDetails}`,
+      `The extension "${extension}" does not support the chain "${unsupportedChainName}"${supportedNetworkDetails}`,
     );
   }
 }

packages/advanced-logic/src/extensions/payment-network/any-to-erc20-proxy.ts

@@ -48,7 +48,7 @@ export default class AnyToErc20ProxyPaymentNetwork extends Erc20FeeProxyPaymentN
           network,
         });
       }
-      if (!this.currencyManager.supportsConversion(acceptedCurrency, network)) {
+      if (!network || !this.currencyManager.supportsConversion(acceptedCurrency, network)) {
         throw Error(
           `acceptedTokens must contain only supported token addresses (ERC20 only). ${address} is not supported for ${network}.`,
         );

packages/advanced-logic/src/extensions/payment-network/any-to-native.ts

@@ -1,5 +1,5 @@
 import { FeeReferenceBasedPaymentNetwork } from './fee-reference-based';
-import { CurrencyTypes, ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { ChainTypes, ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
 import { InvalidPaymentAddressError, UnsupportedNetworkError } from './address-based';
 import { ICurrencyManager } from '@requestnetwork/currency';
 
@@ -8,7 +8,7 @@ export default abstract class AnyToNativeTokenPaymentNetwork extends FeeReferenc
     currencyManager: ICurrencyManager,
     extensionId: ExtensionTypes.PAYMENT_NETWORK_ID,
     currentVersion: string,
-    public readonly supportedNetworks: CurrencyTypes.ChainName[],
+    public readonly supportedNetworks: ChainTypes.IChain[],
   ) {
     super(currencyManager, extensionId, currentVersion, RequestLogicTypes.CURRENCY.ETH);
   }
@@ -46,13 +46,15 @@ export default abstract class AnyToNativeTokenPaymentNetwork extends FeeReferenc
     );
   }
 
-  protected throwIfInvalidNetwork(
-    network?: CurrencyTypes.ChainName,
-  ): asserts network is CurrencyTypes.ChainName {
-    super.throwIfInvalidNetwork(network);
-    if (this.supportedNetworks && !this.supportedNetworks.includes(network)) {
-      throw new UnsupportedNetworkError(network, this.supportedNetworks);
+  protected throwIfInvalidNetwork(chain?: string | ChainTypes.IChain): ChainTypes.IChain {
+    const _chain = super.throwIfInvalidNetwork(chain);
+    if (
+      this.supportedNetworks &&
+      !this.supportedNetworks.some((supportedChain) => supportedChain.eq(_chain))
+    ) {
+      throw new UnsupportedNetworkError(this.constructor.name, _chain.name, this.supportedNetworks);
     }
+    return _chain;
   }
 }