How to use the @requestnetwork/types.RequestLogicTypes.CURRENCY function in @requestnetwork/types

import { EthereumPrivateKeySignatureProvider } from '@requestnetwork/epk-signature';
import { RequestLogic } from '@requestnetwork/request-logic';
import { TransactionManager } from '@requestnetwork/transaction-manager';
import {
  IdentityTypes,
  RequestLogicTypes,
  SignatureProviderTypes,
  SignatureTypes,
  TransactionTypes,
} from '@requestnetwork/types';

import MockStorage from './mock/mock-storage';

const createParams = {
  currency: {
    type: RequestLogicTypes.CURRENCY.ETH,
    value: 'ETH',
  },
  expectedAmount: '170000000000',
  payee: {
    type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
    value: '0xAf083f77F1fFd54218d91491AFD06c9296EaC3ce',
  },
  payer: {
    type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
    value: '0x627306090abab3a6e1400e9345bc60c78a8bef57',
  },
  timestamp: 1544426030,
};

// A signature provider, for example @requestnetwork/epk-signature
const signatureProvider: SignatureProviderTypes.ISignatureProvider = new EthereumPrivateKeySignatureProvider(

}> {
    const requestParameters = parameters.requestInfo;
    const paymentNetworkCreationParameters = parameters.paymentNetwork;
    const contentData = parameters.contentData;
    const topics = parameters.topics || [];

    if (requestParameters.extensionsData) {
      throw new Error('extensionsData in request parameters must be empty');
    }

    // if request currency is a string, convert it to currency object
    if (typeof requestParameters.currency === 'string') {
      requestParameters.currency = stringToCurrency(requestParameters.currency);
    } else {
      // If ERC20, validate that the value is a checksum address
      if (requestParameters.currency.type === RequestLogicTypes.CURRENCY.ERC20) {
        if (!validERC20Address(requestParameters.currency.value)) {
          throw new Error(
            'The ERC20 currency address needs to be a valid Ethereum checksum address',
          );
        }
      }
    }

    // avoid mutation of the parameters
    const copiedRequestParameters = Utils.deepCopy(requestParameters);
    copiedRequestParameters.extensionsData = [];

    let paymentNetwork: Types.IPaymentNetwork | null = null;
    if (paymentNetworkCreationParameters) {
      paymentNetwork = PaymentNetworkFactory.createPaymentNetwork({
        advancedLogic: this.advancedLogic,

import { IdentityTypes, RequestLogicTypes, SignatureTypes } from '@requestnetwork/types';
import MockStorage from './mock-storage';

const signatureInfo: SignatureTypes.ISignatureParameters = {
  method: SignatureTypes.METHOD.ECDSA,
  privateKey: '0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',
};
const signerIdentity: IdentityTypes.IIdentity = {
  type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
  value: '0x627306090abab3a6e1400e9345bc60c78a8bef57',
};

const requestCreationHash: RequestLogicTypes.ICreateParameters = {
  currency: {
    network: 'mainnet',
    type: RequestLogicTypes.CURRENCY.ETH,
    value: 'ETH',
  },
  expectedAmount: '100000000000',
  payee: signerIdentity,
  payer: {
    type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
    value: '0x740fc87Bd3f41d07d23A01DEc90623eBC5fed9D6',
  },
};

// Signature provider setup
const signatureProvider = new EthereumPrivateKeySignatureProvider(signatureInfo);

// Advanced logic setup
const advancedLogic = new AdvancedLogic();

function applyActionToExtension(
  extensionsState: RequestLogicTypes.IExtensionStates,
  extensionAction: ExtensionTypes.IAction,
  requestState: RequestLogicTypes.IRequest,
  actionSigner: IdentityTypes.IIdentity,
  timestamp: number,
): RequestLogicTypes.IExtensionStates {
  // TODO: test for full list of supported ERC20 currencies
  if (requestState.currency.type !== RequestLogicTypes.CURRENCY.ERC20) {
    throw Error(`This extension can be used only on ERC20 requests`);
  }

  return AddressBased.applyActionToExtension(
    isValidAddress,
    extensionsState,
    extensionAction,
    requestState,
    actionSigner,
    timestamp,
  );
}

export async function getDecimalsForCurrency(
  currency: RequestLogicTypes.ICurrency,
): Promise {
  if (currency.type === RequestLogicTypes.CURRENCY.ERC20) {
    return getErc20Decimals(currency);
  }
  // Return the number of decimals for ISO-4217 currencies
  if (currency.type === RequestLogicTypes.CURRENCY.ISO4217) {
    const iso = currencyCodes.code(currency.value);
    if (!iso) {
      throw new Error(`Unsupported ISO currency ${currency.value}`);
    }
    return Promise.resolve(iso.digits);
  }

  const decimals = {
    [RequestLogicTypes.CURRENCY.ETH]: 18,
    [RequestLogicTypes.CURRENCY.BTC]: 8,
  }[currency.type];

  if (!decimals) {
    throw new Error(`Currency ${currency} not implemented`);
  }
  return Promise.resolve(decimals);

switch (currency) {
    case 'BTC':
      return {
        network: 'mainnet',
        type: RequestLogicTypes.CURRENCY.BTC,
        value: 'BTC',
      };
    case 'ETH':
      return {
        network: 'mainnet',
        type: RequestLogicTypes.CURRENCY.ETH,
        value: 'ETH',
      };
    case 'EUR':
      return {
        type: RequestLogicTypes.CURRENCY.ISO4217,
        value: 'EUR',
      };
    case 'USD':
      return {
        type: RequestLogicTypes.CURRENCY.ISO4217,
        value: 'USD',
      };
    case 'DAI': // DON'T RENAME: DAI was the name used by the legacy requests for SAI
      return {
        type: RequestLogicTypes.CURRENCY.ERC20,
        value: '0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359', // SAI
      };
    default:
      throw new Error('Unsupported currency when getting request from transactions.');
  }
}

export function getErc20Currency(
  symbol: string,
  network: string,
): RequestLogicTypes.ICurrency | undefined {
  // If network is mainnet, check if it's one of the supported ERC20
  if (!network || network === 'mainnet') {
    const erc20Token = getErc20FromSymbol(symbol);
    if (erc20Token) {
      return {
        network: 'mainnet',
        type: RequestLogicTypes.CURRENCY.ERC20,
        value: erc20Token.address,
      };
    }
  }

  // Check if it's one of our supported rinkeby ERC20 currencies
  if (supportedRinkebyERC20.has(symbol)) {
    if (network && network === 'rinkeby') {
      return supportedRinkebyERC20.get(symbol)!;
    }
    throw new Error(`The currency ${symbol} is only available on rinkeby`);
  }

  return;
}

function applyActionToExtension(
  extensionsState: RequestLogicTypes.IExtensionStates,
  extensionAction: ExtensionTypes.IAction,
  requestState: RequestLogicTypes.IRequest,
  actionSigner: IdentityTypes.IIdentity,
  timestamp: number,
): RequestLogicTypes.IExtensionStates {
  if (requestState.currency !== RequestLogicTypes.CURRENCY.BTC) {
    throw Error(`This extension can be used only on BTC request`);
  }

  if (extensionAction.id !== ExtensionTypes.ID.PAYMENT_NETWORK_TESTNET_BITCOIN_ADDRESS_BASED) {
    throw Error(
      `This extension is not recognized by the BTC testnet address based payment network`,
    );
  }

  return AddressBased.applyActionToExtension(
    isValidAddress,
    extensionsState,
    extensionAction,
    requestState,
    actionSigner,
    timestamp,

function applyActionToExtension(
  extensionsState: RequestLogicTypes.IExtensionStates,
  extensionAction: ExtensionTypes.IAction,
  requestState: RequestLogicTypes.IRequest,
  actionSigner: IdentityTypes.IIdentity,
  timestamp: number,
): RequestLogicTypes.IExtensionStates {
  if (
    requestState.currency.type !== RequestLogicTypes.CURRENCY.ETH ||
    (requestState.currency.network && !supportedNetworks.includes(requestState.currency.network))
  ) {
    throw Error(
      `This extension can be used only on ETH requests and on supported networks ${supportedNetworks.join(
        ', ',
      )}`,
    );
  }

  return ReferenceBased.applyActionToExtension(
    isValidAddress,
    extensionsState,
    extensionAction,
    requestState,
    actionSigner,
    timestamp,

import { TransactionManager } from '@requestnetwork/transaction-manager';
import {
  DecryptionProviderTypes,
  EncryptionTypes,
  IdentityTypes,
  RequestLogicTypes,
  SignatureProviderTypes,
  SignatureTypes,
  TransactionTypes,
} from '@requestnetwork/types';

import MockStorage from './mock/mock-storage';

const createParams = {
  currency: {
    type: RequestLogicTypes.CURRENCY.ETH,
    value: 'ETH',
  },
  expectedAmount: '170000000000',
  payee: {
    type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
    value: '0xAf083f77F1fFd54218d91491AFD06c9296EaC3ce',
  },
  payer: {
    type: IdentityTypes.TYPE.ETHEREUM_ADDRESS,
    value: '0x627306090abab3a6e1400e9345bc60c78a8bef57',
  },
  timestamp: 1544426030,
};

const payeeEncryptionParameters: EncryptionTypes.IEncryptionParameters = {
  key: