chore(smart-contracts): publish to tenderly

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

@@ -1,5 +1,6 @@
 import {
   AdvancedLogicTypes,
+  CurrencyTypes,
   ExtensionTypes,
   IdentityTypes,
   RequestLogicTypes,
@@ -142,7 +143,7 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
   }
 
   public getNativeTokenExtensionForNetwork(
-    network: string,
+    network: CurrencyTypes.ChainName,
   ): ExtensionTypes.IExtension<ExtensionTypes.PnReferenceBased.ICreationParameters> | undefined {
     return this.extensions.nativeToken.find((nativeTokenExtension) =>
       nativeTokenExtension.supportedNetworks.includes(network),
@@ -167,7 +168,7 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
   }
 
   public getAnyToNativeTokenExtensionForNetwork(
-    network: string,
+    network: CurrencyTypes.ChainName,
   ): ExtensionTypes.IExtension<ExtensionTypes.PnAnyToEth.ICreationParameters> | undefined {
     return this.extensions.anyToNativeToken.find((anyToNativeTokenExtension) =>
       anyToNativeTokenExtension.supportedNetworks.includes(network),
@@ -185,7 +186,7 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
   protected getNetwork(
     extensionAction: ExtensionTypes.IAction,
     requestState: RequestLogicTypes.IRequest,
-  ): string | undefined {
+  ): CurrencyTypes.ChainName | undefined {
     const network =
       extensionAction.action === 'create'
         ? extensionAction.parameters.network

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/src/extensions/payment-network/any-to-native.ts

@@ -1,12 +1,12 @@
 import { FeeReferenceBasedPaymentNetwork } from './fee-reference-based';
-import { ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { CurrencyTypes, ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
 import { InvalidPaymentAddressError, UnsupportedNetworkError } from './address-based';
 
 export default abstract class AnyToNativeTokenPaymentNetwork extends FeeReferenceBasedPaymentNetwork {
   protected constructor(
     extensionId: ExtensionTypes.PAYMENT_NETWORK_ID,
     currentVersion: string,
-    public readonly supportedNetworks: string[],
+    public readonly supportedNetworks: CurrencyTypes.ChainName[],
   ) {
     super(extensionId, currentVersion, RequestLogicTypes.CURRENCY.ETH);
   }
@@ -44,7 +44,9 @@ export default abstract class AnyToNativeTokenPaymentNetwork extends FeeReferenc
     );
   }
 
-  protected throwIfInvalidNetwork(network?: string): asserts network is string {
+  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);

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

@@ -1,4 +1,4 @@
-import { ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { CurrencyTypes, ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
 import { InvalidPaymentAddressError, UnsupportedNetworkError } from './address-based';
 
 import ReferenceBasedPaymentNetwork from './reference-based';
@@ -10,7 +10,7 @@ export default abstract class NativeTokenPaymentNetwork extends ReferenceBasedPa
   public constructor(
     extensionId: ExtensionTypes.PAYMENT_NETWORK_ID,
     currentVersion: string,
-    public readonly supportedNetworks: string[],
+    public readonly supportedNetworks: CurrencyTypes.ChainName[],
   ) {
     super(extensionId, currentVersion, RequestLogicTypes.CURRENCY.ETH);
   }
@@ -50,7 +50,9 @@ export default abstract class NativeTokenPaymentNetwork extends ReferenceBasedPa
     );
   }
 
-  protected throwIfInvalidNetwork(network?: string): asserts network is string {
+  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);

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

@@ -1,13 +1,18 @@
 import { ICurrencyManager, UnsupportedCurrencyError } from '@requestnetwork/currency';
-import { ExtensionTypes, IdentityTypes, RequestLogicTypes } from '@requestnetwork/types';
+import {
+  CurrencyTypes,
+  ExtensionTypes,
+  IdentityTypes,
+  RequestLogicTypes,
+} from '@requestnetwork/types';
 import AnyToNativeTokenPaymentNetwork from '../any-to-native';
 
 const CURRENT_VERSION = '0.1.0';
 
 export default class AnyToNearPaymentNetwork extends AnyToNativeTokenPaymentNetwork {
   public constructor(
     private currencyManager: ICurrencyManager,
-    supportedNetworks: string[] = [
+    supportedNetworks: CurrencyTypes.NearChainName[] = [
       'aurora',
       // FIXME: enable near network support
       // 'near'

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

@@ -1,4 +1,4 @@
-import { ExtensionTypes } from '@requestnetwork/types';
+import { CurrencyTypes, ExtensionTypes } from '@requestnetwork/types';
 import NativeTokenPaymentNetwork from '../native-token';
 
 const CURRENT_VERSION = '0.2.0';
@@ -8,7 +8,7 @@ const CURRENT_VERSION = '0.2.0';
  */
 export default class NearNativePaymentNetwork extends NativeTokenPaymentNetwork {
   public constructor(
-    supportedNetworks: string[] = [
+    supportedNetworks: CurrencyTypes.NearChainName[] = [
       'aurora',
       // FIXME: enable near network support
       // 'near'

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

@@ -37,7 +37,7 @@ describe('extensions/payment-network/address-based', () => {
         super(extensionId, currentVersion, supportedCurrencyType);
       }
       public testIsValidAddress() {
-        this.isValidAddressForSymbolAndNetwork('test', 'test', 'test');
+        this.isValidAddressForSymbolAndNetwork('test', 'test', 'mainnet');
       }
     }
     expect(() => {
@@ -47,6 +47,6 @@ describe('extensions/payment-network/address-based', () => {
         RequestLogicTypes.CURRENCY.ERC20,
       );
       testAddressBasedPaymentNetwork.testIsValidAddress();
-    }).toThrowError(new UnsupportedCurrencyError({ value: 'test', network: 'test' }));
+    }).toThrowError(new UnsupportedCurrencyError({ value: 'test', network: 'mainnet' }));
   });
 });

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

@@ -145,11 +145,11 @@ describe('extensions/payment-network/erc20/any-to-erc20-fee-proxy-contract', ()
         anyToErc20Proxy.createCreationAction({
           paymentAddress: '0x0000000000000000000000000000000000000001',
           salt: 'ea3bc7caf64110ca',
-          network: 'kovan',
+          network: 'goerli',
           acceptedTokens: ['0x0000000000000000000000000000000000000003'],
         });
       }).toThrowError(
-        "The currency '0x0000000000000000000000000000000000000003' on kovan is unknown or not supported.",
+        "The currency '0x0000000000000000000000000000000000000003' on goerli is unknown or not supported.",
       );
     });
 

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

@@ -1,4 +1,4 @@
-import { ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { CurrencyTypes, ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
 import { deepCopy } from '@requestnetwork/utils';
 import { CurrencyManager, UnsupportedCurrencyError } from '@requestnetwork/currency';
 
@@ -146,7 +146,7 @@ describe('extensions/payment-network/ethereum/any-to-eth-fee-proxy-contract', ()
       requestCreatedNoExtension.currency = {
         type: RequestLogicTypes.CURRENCY.ETH,
         value: 'invalid value',
-        network: 'invalid network',
+        network: 'invalid network' as CurrencyTypes.EvmChainName,
       };
 
       const action: ExtensionTypes.IAction = deepCopy(

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.NearChainName,
               });
             }).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}`, () => {
@@ -148,7 +148,7 @@ describe('extensions/payment-network/native-token', () => {
       expect(() => {
         new NearNativePaymentNetwork().createCreationAction({
           ...partialCreationParams,
-          paymentNetworkName: 'another-chain',
+          paymentNetworkName: 'another-chain' as CurrencyTypes.NearChainName,
         });
       }).toThrowError(
         `Payment network 'another-chain' is not supported by this extension (only aurora)`,
@@ -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/README.md

@@ -1,7 +1,7 @@
 # @requestnetwork/currency
 
 `@requestnetwork/currency` is a typescript library part of the [Request Network protocol](https://github.com/RequestNetwork/requestNetwork).
-It is a collection of tools for the currencies shared between the @requestnetwork packages.
+It is a collection of tools for the currencies and chains shared between the @requestnetwork packages.
 
 ## Installation
 

packages/currency/src/chains/ChainsAbstract.ts

@@ -0,0 +1,69 @@
+import { Chain, NamedNativeCurrency, TokenMap } from '../types';
+import { CurrencyTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { nativeCurrencies } from '../native';
+
+export abstract class ChainsAbstract<
+  CHAIN_NAME extends CurrencyTypes.ChainName,
+  CHAIN extends Chain,
+  CHAIN_ID extends string | number,
+> {
+  public chains: Record<CHAIN_NAME, CHAIN>;
+  public chainNames: CHAIN_NAME[];
+
+  constructor(
+    chains: Record<CHAIN_NAME, CHAIN>,
+    currencyType: RequestLogicTypes.CURRENCY.ETH | RequestLogicTypes.CURRENCY.BTC,
+  ) {
+    this.chains = chains;
+    this.chainNames = Object.keys(chains) as CHAIN_NAME[];
+    this.addNativeCurrenciesToChains(currencyType);
+  }
+
+  /**
+   * Adds the native currency to the list of currencies supported by each chain
+   */
+  private addNativeCurrenciesToChains(
+    currencyType: RequestLogicTypes.CURRENCY.ETH | RequestLogicTypes.CURRENCY.BTC,
+  ): void {
+    this.chainNames.forEach((chainName) => {
+      const nativeCurrency = (nativeCurrencies[currencyType] as NamedNativeCurrency[]).find(
+        (currency) => currency.network === chainName,
+      );
+      if (nativeCurrency) {
+        const chainCurrencies: TokenMap = this.chains[chainName].currencies || {};
+        chainCurrencies.native = nativeCurrency;
+        this.chains[chainName].currencies = chainCurrencies;
+      }
+    });
+  }
+
+  /**
+   * Check if chainName lives amongst the list of supported chains by this chain type.
+   * Throws in the case it's not supported.
+   */
+  public assertChainSupported(chainName?: string): asserts chainName is CHAIN_NAME {
+    if (!chainName || !(this.chainNames as string[]).includes(chainName))
+      throw new Error(`Unsupported chain ${chainName}`);
+  }
+
+  /**
+   * Retrieve the corresponding chain ID from Request Network's internal chain name representation
+   */
+  public getChainId(chainName: CHAIN_NAME): CHAIN_ID {
+    return this.chains[chainName].chainId as CHAIN_ID;
+  }
+
+  /**
+   * Retrieve Request Network's internal chain name representation from the corresponding chain ID
+   */
+  public getChainName(chainId: CHAIN_ID): CHAIN_NAME | undefined {
+    return this.chainNames.find((chainName) => this.chains[chainName].chainId === chainId);
+  }
+
+  /**
+   * Returns true is the chain is a testnet chain
+   */
+  public isTestnet(chainName: CHAIN_NAME): boolean {
+    return Boolean(this.chains[chainName].testnet);
+  }
+}

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

@@ -0,0 +1,6 @@
+import { ChainsAbstract } from '../ChainsAbstract';
+import { CurrencyTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { BtcChain, chains } from './index';
+
+class BtcChains extends ChainsAbstract<CurrencyTypes.BtcChainName, BtcChain, string> {}
+export default new BtcChains(chains, RequestLogicTypes.CURRENCY.BTC);

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { CurrencyTypes } from '@requestnetwork/types';
+import { Chain } from '../../types';
+
+import * as MainnetDefinition from './data/mainnet';
+import * as TestnetDefinition from './data/testnet';
+
+export type BtcChain = Chain & {
+  chainId: string;
+};
+
+export const chains: Record<CurrencyTypes.BtcChainName, BtcChain> = {
+  mainnet: MainnetDefinition,
+  testnet: TestnetDefinition,
+};