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-erc20-proxy.test.ts

@@ -145,7 +145,7 @@ describe('extensions/payment-network/erc20/any-to-erc20-fee-proxy-contract', ()
         anyToErc20Proxy.createCreationAction({
           paymentAddress: '0x0000000000000000000000000000000000000001',
           salt: 'ea3bc7caf64110ca',
-          network: 'kovan',
+          network: 'goerli',
           acceptedTokens: ['0x0000000000000000000000000000000000000003'],
         });
       }).toThrowError(

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/advanced-logic/test/extensions/payment-network/native-token.test.ts

@@ -11,7 +11,7 @@ import {
 } from '../../utils/payment-network/mocked_native_data';
 import { AdvancedLogic } from '../../../src';
 import { arbitraryTimestamp, payeeRaw } from '../../utils/test-data-generator';
-import { ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { CurrencyTypes, ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
 import NearTestnetNativeNativePaymentNetwork from '../../../src/extensions/payment-network/near/near-testnet-native';
 
 const salt = arbitrarySalt;
@@ -21,17 +21,17 @@ describe('extensions/payment-network/native-token', () => {
     type: RequestLogicTypes.CURRENCY.ETH,
     value: 'NEAR',
     network: 'aurora',
-  };
+  } as const;
   const auroraTestnetCurrency = {
     type: RequestLogicTypes.CURRENCY.ETH,
     value: 'NEAR-testnet',
     network: 'aurora-testnet',
-  };
+  } as const;
   const nearTestnetCurrency = {
     type: RequestLogicTypes.CURRENCY.ETH,
     value: 'NEAR-testnet',
     network: 'near-testnet',
-  };
+  } as const;
   const nativeTokenTestCases = [
     {
       name: 'Near',
@@ -60,7 +60,7 @@ describe('extensions/payment-network/native-token', () => {
       currency: nearTestnetCurrency,
       wrongCurrency: nearCurrency,
     },
-  ];
+  ] as const;
 
   nativeTokenTestCases.forEach((testCase) => {
     describe(`action creations for ${testCase.name}`, () => {
@@ -325,7 +325,7 @@ describe('extensions/payment-network/native-token', () => {
     });
     it('throws on a wrong payment network', () => {
       const advancedLogic = new AdvancedLogic();
-      const wrongNetwork = `wrong network`;
+      const wrongNetwork = `wrong network` as CurrencyTypes.EvmChainName;
 
       const wrongNativeTokenRequestState: typeof requestStateNoExtensions = {
         ...requestStateNoExtensions,

packages/advanced-logic/test/utils/payment-network/erc777/stream-create-data-generator.ts

@@ -160,7 +160,7 @@ const baseRequestState = {
   state: RequestLogicTypes.STATE.CREATED,
   timestamp: TestData.arbitraryTimestamp,
   version,
-};
+} as const;
 
 const baseRequestEvent = {
   actionSigner: {
@@ -174,7 +174,7 @@ const baseRequestEvent = {
     isSignedRequest: false,
   },
   timestamp: arbitraryTimestamp,
-};
+} as const;
 
 export const requestStateNoExtensions: RequestLogicTypes.IRequest = {
   ...baseRequestState,

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 };