refactor: chain configurations

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

@@ -1,5 +1,10 @@
 import { CurrencyManager, UnsupportedCurrencyError } from '@requestnetwork/currency';
-import { ExtensionTypes, IdentityTypes, RequestLogicTypes } from '@requestnetwork/types';
+import {
+  CurrencyTypes,
+  ExtensionTypes,
+  IdentityTypes,
+  RequestLogicTypes,
+} from '@requestnetwork/types';
 import { areEqualIdentities, deepCopy } from '@requestnetwork/utils';
 import DeclarativePaymentNetwork from './declarative';
 
@@ -155,7 +160,7 @@ export default abstract class AddressBasedPaymentNetwork<
   protected isValidAddressForSymbolAndNetwork(
     address: string,
     symbol: string,
-    network: string,
+    network: CurrencyTypes.ChainName,
   ): boolean {
     const currencyManager = CurrencyManager.getDefault();
     const currency = currencyManager.from(symbol, network);

packages/advanced-logic/test/extensions/payment-network/any-to-near.test.ts

@@ -8,7 +8,7 @@ import {
 } from '../../utils/payment-network/any/generator-data-create';
 import { AdvancedLogic } from '../../../src';
 import { arbitraryTimestamp, payeeRaw, payerRaw } from '../../utils/test-data-generator';
-import { ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { CurrencyTypes, ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
 import AnyToNearPaymentNetwork from '../../../src/extensions/payment-network/near/any-to-near';
 import AnyToNativeTokenPaymentNetwork from '../../../src/extensions/payment-network/any-to-native';
 import { CurrencyManager } from '@requestnetwork/currency';
@@ -52,7 +52,7 @@ describe('extensions/payment-network/any-to-native-token', () => {
       maxRateTimespan: 100000,
       feeAmount: '100',
     },
-  ];
+  ] as const;
 
   anyToNativeTokenTestCases.forEach((testCase) => {
     describe(`action creations for ${testCase.name}`, () => {
@@ -184,7 +184,7 @@ describe('extensions/payment-network/any-to-native-token', () => {
             expect(() => {
               new AnyToNearPaymentNetwork(currencyManager).createCreationAction({
                 ...partialCreationParams,
-                network: 'another-chain',
+                network: 'another-chain' as CurrencyTypes.EvmChainName,
               });
             }).toThrowError(
               `Payment network 'another-chain' is not supported by this extension (only aurora)`,

packages/currency/src/chains/btc/index.ts

@@ -0,0 +1,32 @@
+import { CurrencyTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { BtcChainDefinition } from '../../types';
+import { addNativeCurrenciesToChains, genericAssertChainSupported } from '../utils';
+
+import * as MainnetDefinition from './mainnet';
+import * as TestnetDefinition from './testnet';
+
+export const chains: Record<CurrencyTypes.BtcChainName, BtcChainDefinition> = {
+  mainnet: MainnetDefinition,
+  testnet: TestnetDefinition,
+};
+
+export const chainNames = Object.keys(chains) as CurrencyTypes.BtcChainName[];
+
+// add native currencies
+addNativeCurrenciesToChains(chains, RequestLogicTypes.CURRENCY.BTC);
+
+/**
+ * Asserts if a specific chain is supported across BTC-type supported chains
+ * @param chainName
+ */
+export function assertChainSupported(
+  chainName: string,
+): asserts chainName is CurrencyTypes.BtcChainName {
+  genericAssertChainSupported<CurrencyTypes.BtcChainName>(chainName, chainNames);
+}
+
+export const getChainId = (chainName: CurrencyTypes.BtcChainName): string =>
+  chains[chainName].chainId;
+
+export const getChainName = (chainId: string): CurrencyTypes.BtcChainName | undefined =>
+  chainNames.find((chainName) => chains[chainName].chainId === chainId);

packages/currency/src/chains/btc/mainnet.ts

@@ -0,0 +1 @@
+export const chainId = '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f';

packages/currency/src/chains/btc/testnet.ts

@@ -0,0 +1 @@
+export const chainId = '000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943';

packages/currency/src/chains/evm/alfajores.ts

@@ -0,0 +1 @@
+export const chainId = 44787;

packages/currency/src/chains/evm/arbitrum-one.ts

@@ -0,0 +1 @@
+export const chainId = 42161;

packages/currency/src/chains/evm/arbitrum-rinkeby.ts

@@ -0,0 +1 @@
+export const chainId = 421611;

packages/currency/src/chains/evm/aurora-testnet.ts

@@ -0,0 +1 @@
+export const chainId = 1313161555;

packages/currency/src/chains/evm/aurora.ts

@@ -0,0 +1 @@
+export const chainId = 1313161554;

packages/currency/src/chains/evm/avalanche.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedAvalancheERC20 } from '../../erc20/chains/avalanche';
+
+export const chainId = 43114;
+export const currencies: TokenMap = {
+  ...supportedAvalancheERC20,
+};

packages/currency/src/chains/evm/bsc.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedBSCERC20 } from '../../erc20/chains/bsc';
+
+export const chainId = 56;
+export const currencies: TokenMap = {
+  ...supportedBSCERC20,
+};

packages/currency/src/chains/evm/bsctest.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedBSCTestERC20 } from '../../erc20/chains/bsctest';
+
+export const chainId = 97;
+export const currencies: TokenMap = {
+  ...supportedBSCTestERC20,
+};

packages/currency/src/chains/evm/celo.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedCeloERC20 } from '../../erc20/chains/celo';
+
+export const chainId = 42220;
+export const currencies: TokenMap = {
+  ...supportedCeloERC20,
+};

packages/currency/src/chains/evm/fantom.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedFantomTokens } from '../../erc20/chains/fantom';
+
+export const chainId = 250;
+export const currencies: TokenMap = {
+  ...supportedFantomTokens,
+};

packages/currency/src/chains/evm/fuse.ts

@@ -0,0 +1 @@
+export const chainId = 122;

packages/currency/src/chains/evm/goerli.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedGoerliERC20 } from '../../erc20/chains/goerli';
+
+export const chainId = 5;
+export const currencies: TokenMap = {
+  ...supportedGoerliERC20,
+};

packages/currency/src/chains/evm/index.ts

@@ -0,0 +1,76 @@
+import { CurrencyTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { EvmChainDefinition } from '../../types';
+import { addNativeCurrenciesToChains, genericAssertChainSupported } from '../utils';
+
+import * as AlfajoresDefinition from './alfajores';
+import * as ArbitrumOneDefinition from './arbitrum-one';
+import * as ArbitrumRinkebyDefinition from './arbitrum-rinkeby';
+import * as AuroraDefinition from './aurora';
+import * as AuroraTestnetDefinition from './aurora-testnet';
+import * as AvalancheDefinition from './avalanche';
+import * as BscDefinition from './bsc';
+import * as BscTestDefinition from './bsctest';
+import * as CeloDefinition from './celo';
+import * as FantomDefinition from './fantom';
+import * as FuseDefinition from './fuse';
+import * as GoerliDefinition from './goerli';
+import * as MainnetDefinition from './mainnet';
+import * as MaticDefinition from './matic';
+import * as MoonbeamDefinition from './moonbeam';
+import * as MumbaiDefinition from './mumbai';
+import * as OptimismDefinition from './optimism';
+import * as PrivateDefinition from './private';
+import * as RinkebyDefinition from './rinkeby';
+import * as RoninDefinition from './ronin';
+import * as SokolDefinition from './sokol';
+import * as TombchainDefinition from './tombchain';
+import * as XDaiDefinition from './xdai';
+
+export const chains: Record<CurrencyTypes.EvmChainName, EvmChainDefinition> = {
+  alfajores: AlfajoresDefinition,
+  'arbitrum-one': ArbitrumOneDefinition,
+  'arbitrum-rinkeby': ArbitrumRinkebyDefinition,
+  aurora: AuroraDefinition,
+  'aurora-testnet': AuroraTestnetDefinition,
+  avalanche: AvalancheDefinition,
+  bsc: BscDefinition,
+  bsctest: BscTestDefinition,
+  celo: CeloDefinition,
+  fantom: FantomDefinition,
+  fuse: FuseDefinition,
+  goerli: GoerliDefinition,
+  mainnet: MainnetDefinition,
+  matic: MaticDefinition,
+  moonbeam: MoonbeamDefinition,
+  mumbai: MumbaiDefinition,
+  'near-testnet': AuroraTestnetDefinition,
+  optimism: OptimismDefinition,
+  private: PrivateDefinition,
+  // FIXME: Rinkeby is deprecated
+  rinkeby: RinkebyDefinition,
+  ronin: RoninDefinition,
+  sokol: SokolDefinition,
+  tombchain: TombchainDefinition,
+  xdai: XDaiDefinition,
+};
+
+export const chainNames = Object.keys(chains) as CurrencyTypes.EvmChainName[];
+
+// add native currencies
+addNativeCurrenciesToChains(chains, RequestLogicTypes.CURRENCY.ETH);
+
+/**
+ * Asserts if a specific chain is supported across EVM-type supported chains
+ * @param chainName
+ */
+export function assertChainSupported(
+  chainName: string,
+): asserts chainName is CurrencyTypes.EvmChainName {
+  genericAssertChainSupported<CurrencyTypes.EvmChainName>(chainName, chainNames);
+}
+
+export const getChainId = (chainName: CurrencyTypes.EvmChainName): number =>
+  chains[chainName].chainId;
+
+export const getChainName = (chainId: number): CurrencyTypes.EvmChainName | undefined =>
+  chainNames.find((chainName) => chains[chainName].chainId === chainId);

packages/currency/src/chains/evm/mainnet.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedMainnetERC20 } from '../../erc20/chains/mainnet';
+
+export const chainId = 1;
+export const currencies: TokenMap = {
+  ...supportedMainnetERC20,
+};

packages/currency/src/chains/evm/matic.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedMaticERC20 } from '../../erc20/chains/matic';
+
+export const chainId = 137;
+export const currencies: TokenMap = {
+  ...supportedMaticERC20,
+};

packages/currency/src/chains/evm/moonbeam.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedMoonbeamERC20 } from '../../erc20/chains/moonbeam';
+
+export const chainId = 1284;
+export const currencies: TokenMap = {
+  ...supportedMoonbeamERC20,
+};

packages/currency/src/chains/evm/mumbai.ts

@@ -0,0 +1 @@
+export const chainId = 80001;

packages/currency/src/chains/evm/optimism.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedOptimismERC20 } from '../../erc20/chains/optimism';
+
+export const chainId = 10;
+export const currencies: TokenMap = {
+  ...supportedOptimismERC20,
+};

packages/currency/src/chains/evm/private.ts

@@ -0,0 +1 @@
+export const chainId = 0;

packages/currency/src/chains/evm/rinkeby.ts

@@ -0,0 +1,9 @@
+import { TokenMap } from '../../types';
+import { supportedRinkebyERC20 } from '../../erc20/chains/rinkeby';
+import { supportedRinkebyERC777 } from '../../erc777/chains/rinkeby';
+
+export const chainId = 4;
+export const currencies: TokenMap = {
+  ...supportedRinkebyERC20,
+  ...supportedRinkebyERC777,
+};

packages/currency/src/chains/evm/ronin.ts

@@ -0,0 +1 @@
+export const chainId = 2020;

packages/currency/src/chains/evm/sokol.ts

@@ -0,0 +1 @@
+export const chainId = 77;

packages/currency/src/chains/evm/tombchain.ts

@@ -0,0 +1 @@
+export const chainId = 6969;

packages/currency/src/chains/evm/xdai.ts

@@ -0,0 +1,7 @@
+import { TokenMap } from '../../types';
+import { supportedXDAIERC20 } from '../../erc20/chains/xdai';
+
+export const chainId = 100;
+export const currencies: TokenMap = {
+  ...supportedXDAIERC20,
+};

packages/currency/src/chains/index.ts

@@ -0,0 +1,25 @@
+import { CurrencyTypes } from '@requestnetwork/types';
+import * as EVM from './evm';
+import * as BTC from './btc';
+
+/**
+ * Asserts if a specific chain is supported across all supported chain types (EVM + BTC)
+ * @param chainName
+ */
+export function assertChainSupported(
+  chainName: string,
+): asserts chainName is CurrencyTypes.EvmChainName {
+  const chainSupported = [EVM, BTC].some((chainType) => {
+    try {
+      chainType.assertChainSupported(chainName);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  });
+  if (!chainSupported) {
+    throw new Error(`Unsupported chain ${chainName}`);
+  }
+}
+
+export { EVM, BTC };

packages/currency/src/chains/utils.ts

@@ -0,0 +1,28 @@
+import { nativeCurrencies } from '../native';
+import { ChainDefinition, NamedNativeCurrency, TokenMap } from '../types';
+import { RequestLogicTypes } from '@requestnetwork/types';
+
+export function genericAssertChainSupported<T extends string>(
+  chainKey: string,
+  supportedChains: T[],
+): asserts chainKey is T {
+  if (!(supportedChains as string[]).includes(chainKey))
+    throw new Error(`Unsupported chain ${chainKey}`);
+}
+
+export const addNativeCurrenciesToChains = (
+  chains: Record<string, ChainDefinition>,
+  currencyType: RequestLogicTypes.CURRENCY.ETH | RequestLogicTypes.CURRENCY.BTC,
+): void => {
+  const chainNames = Object.keys(chains);
+  chainNames.forEach((chainName) => {
+    const nativeCurrency = (nativeCurrencies[currencyType] as NamedNativeCurrency[]).find(
+      (currency) => currency.network === chainName,
+    );
+    if (nativeCurrency) {
+      const chainCurrencies: TokenMap = chains[chainName].currencies || {};
+      chainCurrencies.native = nativeCurrency;
+      chains[chainName].currencies = chainCurrencies;
+    }
+  });
+};

packages/currency/src/erc20/networks/avalanche.ts → packages/currency/src/erc20/chains/avalanche.ts

@@ -1,4 +1,4 @@
-import { TokenMap } from './types';
+import { TokenMap } from '../../types';
 
 // List of the supported bsc network tokens
 export const supportedAvalancheERC20: TokenMap = {

packages/currency/src/erc20/networks/bsc.ts → packages/currency/src/erc20/chains/bsc.ts

@@ -1,4 +1,4 @@
-import { TokenMap } from './types';
+import { TokenMap } from '../../types';
 
 // List of the supported bsc network tokens
 export const supportedBSCERC20: TokenMap = {

packages/currency/src/erc20/networks/bsctest.ts → packages/currency/src/erc20/chains/bsctest.ts

@@ -1,4 +1,4 @@
-import { TokenMap } from './types';
+import { TokenMap } from '../../types';
 
 // List of the supported bsctest network tokens
 export const supportedBSCTestERC20: TokenMap = {

packages/currency/src/erc20/networks/celo.ts → packages/currency/src/erc20/chains/celo.ts

@@ -1,4 +1,4 @@
-import { TokenMap } from './types';
+import { TokenMap } from '../../types';
 
 // List of the supported celo network tokens
 export const supportedCeloERC20: TokenMap = {

packages/currency/src/erc20/networks/fantom.ts → packages/currency/src/erc20/chains/fantom.ts

@@ -1,4 +1,4 @@
-import { TokenMap } from './types';
+import { TokenMap } from '../../types';
 
 export const supportedFantomTokens: TokenMap = {
   '0xD3b71117E6C1558c1553305b44988cd944e97300': {

packages/currency/src/erc20/networks/goerli.ts → packages/currency/src/erc20/chains/goerli.ts

@@ -1,4 +1,4 @@
-import { TokenMap } from './types';
+import { TokenMap } from '../../types';
 
 // List of the supported goerli ERC20 tokens
 export const supportedGoerliERC20: TokenMap = {