Fix & extend JSDoc notes

- Simplify getGasParams function by including additional L1 fee in gasLimit
	- Make calculateRefund functions non-async by providing gas price (its ok, because refund needs to be calculated only on user side, where gas price is known)
	- Allow passing to calculateWithdrawalFeeViaRelayer function predefined gas price and gas limit to not refetch/recalculate those values
	- Pass arguments as objects to functions with many optional parameters

.gitignore

@@ -90,4 +90,5 @@ sw.*
 # Vim swap files
 *.swp
 
-test
+test
+TODO

README.md

@@ -35,7 +35,7 @@ const tx: TransactionData = {
 };
 
 const feeOracle = new TornadoFeeOracleV5(1, 'https://eth.llamarpc.com'); // First parameter - chain ID
-const withdrawalGas = await feeOracle.getGas(tx, 'relayer_withdrawal');
+const withdrawalGas = await feeOracle.getGas({tx, txType: 'relayer_withdrawal'});
 ```
 
 ##### Estimate gas price and gas limit to send transaction
@@ -51,10 +51,9 @@ const incompleteTx: TransactionData = {
 
 const feeOracle = new TornadoFeeOracleV5(1, 'https://eth.llamarpc.com');
 const transactionType: TxType = 'relayer_withdrawal';
-const gasPrice = await feeOracle.getGasPrice(transactionType);
+const { gasPrice, gasLimit } = await feeOracle.getGasParams({tx: incompleteTx, txType: transactionType});
-const gasLimit = await feeOracle.getGasLimit(incompleteTx, transactionType);
 
-const tx: TransactionData = Object.assign({ gasPrice, gasLimit }, incompleteTx);
+const tx: TransactionData = {...incompleteTx, gasPrice, gasLimit}
 ```
 
 ##### Get token prices (rate to ETH) for tokens that used in Tornado

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tornado/tornado-oracles",
-  "version": "1.0.0",
+  "version": "3.3.0",
-  "description": "Gas oracle for Tornado-specific transactions",
+  "description": "Oracles for Tornado-specific transactions & actions",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {
@@ -11,7 +11,8 @@
     "prettier:fix": "prettier --write . --config .prettierrc",
     "build:abi": "yarn typechain --target ethers-v5  --out-dir src/contracts ./abis/*.abi.json",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "prepare": "npm run build && npm run build:esm"
+    "prepare": "npm run build && npm run build:esm",
+    "prepublish": "npm run prettier:fix"
   },
   "repository": {
     "type": "git",

src/config.ts

@@ -11,6 +11,14 @@ export enum ChainId {
   AVAX = 43114,
 }
 
+export enum InstanceTokenSymbol {
+  DAI = 'dai',
+  cDAI = 'cdai',
+  WBTC = 'wbtc',
+  USDT = 'usdt',
+  USDC = 'usdc',
+}
+
 export type GasPricesConfig = {
   [chainId in ChainId]: LegacyGasPrices;
 };
@@ -81,6 +89,18 @@ export const defaultWithdrawalGasLimit: GasLimitConfig = {
   [ChainId.XDAI]: 390000,
 };
 
+type InstanceTokenGasLimitConfig = {
+  [tokenSymbol in InstanceTokenSymbol]: number;
+};
+
+export const defaultInstanceTokensGasLimit: InstanceTokenGasLimitConfig = {
+  [InstanceTokenSymbol.DAI]: 55000,
+  [InstanceTokenSymbol.cDAI]: 425000,
+  [InstanceTokenSymbol.WBTC]: 85000,
+  [InstanceTokenSymbol.USDT]: 100000,
+  [InstanceTokenSymbol.USDC]: 80000,
+};
+
 export const optimismL1FeeOracleAddress = '0x420000000000000000000000000000000000000F';
 export const offchainOracleAddress = '0x07D91f5fb9Bf7798734C3f606dB065549F6893bb';
 export const multiCallAddress = '0xda3c19c6fe954576707fa24695efb830d9cca1ca';

src/feeOracle.ts

@@ -1,17 +1,30 @@
 import { GasPriceOracle } from '@tornado/gas-price-oracle';
 import { BigNumber, BigNumberish, ethers } from 'ethers';
+import BigNumberFloat from 'bignumber.js';
 import { parseUnits } from 'ethers/lib/utils';
-import { TransactionData, TxType, ITornadoFeeOracle, LegacyGasPriceKey, GasPriceParams } from './types';
+import {
+  TransactionData,
+  TxType,
+  ITornadoFeeOracle,
+  LegacyGasPriceKey,
+  GasPriceParams,
+  GetGasParamsRes,
+  HexadecimalStringifiedNumber,
+  GetGasInput,
+  GetGasParamsInput,
+} from './types';
 import { JsonRpcProvider } from '@ethersproject/providers';
-import { ChainId, defaultGasPrices } from './config';
+import { ChainId, defaultGasPrices, defaultInstanceTokensGasLimit, InstanceTokenSymbol } from './config';
 import { bump, calculateGasPriceInWei, convertETHToToken, fromGweiToWeiHex, serializeTx } from './utils';
 import { getOptimismL1FeeOracle } from './contracts/factories';
+import { GetWithdrawalFeeViaRelayerInput } from './types';
 import { AvailableTokenSymbols } from '@tornado/tornado-config';
 
 export abstract class TornadoFeeOracle implements ITornadoFeeOracle {
   protected provider: JsonRpcProvider;
 
   public constructor(
+    public version: 4 | 5,
     protected chainId: ChainId,
     rpcUrl: string,
     protected oracle: GasPriceOracle,
@@ -22,52 +35,97 @@ export abstract class TornadoFeeOracle implements ITornadoFeeOracle {
   /**
    * Because Optimism transaction published on Mainnet, for each OP transaction we need to calculate L1 security fee:
    * https://community.optimism.io/docs/developers/build/transaction-fees/#priority-fee
-   * @param {TransactionData} tx Transaction data to estimate L1 additional fee
+   * @param {TransactionData} [tx] Transaction data to estimate L1 additional fee
-   * @returns Fee in WEI (MATIC)
+   * @returns {Promise<HexadecimalStringifiedNumber>} Fee in WEI (MATIC), '0' if chain is not Optimism
    */
-  private async fetchL1OptimismFee(tx?: TransactionData): Promise<BigNumber> {
+  async fetchL1OptimismFee(tx?: TransactionData): Promise<HexadecimalStringifiedNumber> {
-    if (this.chainId != ChainId.OPTIMISM) return BigNumber.from(0);
+    if (this.chainId != ChainId.OPTIMISM) return BigNumber.from(0).toHexString();
 
     const optimismL1FeeOracle = getOptimismL1FeeOracle(this.provider);
+    const l1Fee = await optimismL1FeeOracle.getL1Fee(serializeTx(tx));
 
-    return await optimismL1FeeOracle.getL1Fee(serializeTx(tx));
+    return l1Fee.toHexString();
+  }
+
+  /**
+   * Estimate gas price, gas limit and l1Fee for sidechain (if exists)
+   * @param {GetGasParamsInput} [params] Function input arguments object
+   * @param {TransactionData} [params.tx] Transaction data in web3 / ethers format
+   * @param {TxType} [params.txType=other] Tornado transaction type: withdrawal by user, withdrawal by relayer or 'other'
+   * @param {number} [params.predefinedGasLimit] Predefined gas limit, if already calculated (no refetching)
+   * @param {number} [params.predefinedGasPrice] Predefined gas price, if already calculated (no refetching)
+   * @param {number} [params.bumpGasLimitPercent] Gas limit bump percent to prioritize transaction (if gas limit not predefined, recenlty used)
+   * @param {number} [params.bumpGasPricePercent] Gas price bump percent to prioritize transaction (if gas limit not predefined, rarely used)
+   * @param {LegacyGasPriceKey} [params.speed] Preferred transaction speed, if uses legacy gas (before EIP-1559)
+   * @param {boolean} [params.includeL1FeeToGasLimit=true] Include L1 additional fee on Optimism to gas limit (get fee and divide by gas price)
+   * @returns {Promise<GetGasParamsRes>} Object with fields 'gasPrice' and 'gasLimit', L1 fee, if exists, included in gasLimit
+   */
+  async getGasParams(params: GetGasParamsInput = {}): Promise<GetGasParamsRes> {
+    let {
+      tx,
+      txType = 'other',
+      bumpGasLimitPercent,
+      bumpGasPricePercent,
+      predefinedGasLimit: gasLimit,
+      predefinedGasPrice: gasPrice,
+      speed,
+      includeL1FeeToGasLimit = true,
+    } = params;
+
+    let l1Fee: string = '0';
+    if (!gasLimit && !gasPrice) {
+      [gasPrice, gasLimit, l1Fee] = await Promise.all([
+        this.getGasPrice(speed, bumpGasPricePercent),
+        this.getGasLimit(tx, txType, bumpGasLimitPercent),
+        this.fetchL1OptimismFee(tx),
+      ]);
+    }
+    if (!gasLimit) {
+      [gasLimit, l1Fee] = await Promise.all([
+        this.getGasLimit(tx, txType, bumpGasLimitPercent),
+        this.fetchL1OptimismFee(tx),
+      ]);
+    }
+    if (!gasPrice) gasPrice = await this.getGasPrice(speed, bumpGasPricePercent);
+
+    if (includeL1FeeToGasLimit)
+      // Include L1 fee in gas limit (divide by gas price before), if l1 fee is 0, gas limit wont change
+      gasLimit = BigNumberFloat(gasLimit)
+        .plus(BigNumberFloat(l1Fee).div(BigNumberFloat(gasPrice)))
+        .decimalPlaces(0, 1)
+        .toNumber();
+
+    return { gasLimit, gasPrice };
   }
 
   /**
    * Estimates next block gas for signed, unsigned or incomplete Tornado transaction
-   * @param {TransactionData} tx Transaction data in web3 / ethers format
+   * @param {GetGasInput} [params] Function input arguments object
-   * @param {TxType} txType Tornado transaction type: withdrawal by user, withdrawal by relayer or 'other'
+   * @param {TransactionData} [params.tx] Transaction data in web3 / ethers format
-   * @param {LegacyGasPriceKey} speed Preferred transaction speed, if uses legacy gas (before EIP-1559)
+   * @param {TxType} [params.txType] Tornado transaction type: withdrawal by user, withdrawal by relayer or 'other'
-   * @returns {Promise<string>} Gas value in WEI (hex-format)
+   * @param {number} [params.predefinedGasLimit] Predefined gas limit, if already calculated (no refetching)
+   * @param {number} [params.predefinedGasPrice] Predefined gas price, if already calculated (no refetching)
+   * @param {number} [params.bumpGasLimitPercent] Gas limit bump percent to prioritize transaction (if gas limit not predefined, recenlty used)
+   * @param {number} [params.bumpGasPricePercent] Gas price bump percent to prioritize transaction (if gas price not predefined, rarely used)
+   * @param {LegacyGasPriceKey} [params.speed] Preferred transaction speed, if uses legacy gas (before EIP-1559)
+   * @returns {Promise<HexadecimalStringifiedNumber>} Gas value in WEI (hex-format)
    */
-  public async getGas(
+  async getGas(params: GetGasInput = {}): Promise<HexadecimalStringifiedNumber> {
-    tx?: TransactionData,
+    const { gasPrice, gasLimit } = await this.getGasParams({ ...params, includeL1FeeToGasLimit: true });
-    txType: TxType = 'other',
-    speed: LegacyGasPriceKey = 'fast',
-  ): Promise<string> {
-    const gasPrice = await this.getGasPrice(txType, speed);
-    let gas = BigNumber.from(0);
-    gas = gas.add(gasPrice);
-    if (tx) tx = Object.assign(tx, { gasPrice });
-    gas = gas.mul(await this.getGasLimit(tx, txType));
-    if (this.chainId === ChainId.OPTIMISM) gas = gas.add(await this.fetchL1OptimismFee(tx));
 
-    return gas.toHexString();
+    return BigNumber.from(gasPrice).mul(gasLimit).toHexString();
   }
 
   /**
    * Estimate next block gas price
-   * @param {TxType} type Tornado transaction type (to select correct default bump percent)
+   * @param {LegacyGasPriceKey} [speed] Preferred transaction speed, if uses legacy gas (before EIP-1559)
-   * @param {LegacyGasPriceKey} speed Preferred transaction speed, if uses legacy gas (before EIP-1559)
+   * @param {number} [bumpPercent=0] Gas bump percent to prioritize transaction
-   * @param {number} bumpPercent Gas bump percent to prioritize transaction
    * @returns {Promise<GasPriceParams>} Estimated gas price info in WEI (hexed) - legacy object with gasPrice property or
    * EIP-1559 object with maxFeePerGas and maxPriorityFeePerGas properties
    */
-  async getGasPriceParams(
+  async getGasPriceParams(speed?: LegacyGasPriceKey, bumpPercent: number = 0): Promise<GasPriceParams> {
-    type: TxType = 'other',
+    // Use instant for BSC, because on this chain "fast" and "instant" differs more than third and "fast" transaction can take hours
-    speed: LegacyGasPriceKey = 'fast',
+    if (!speed) speed = this.chainId === ChainId.BSC ? 'instant' : 'fast';
-    bumpPercent: number = 0,
-  ): Promise<GasPriceParams> {
     try {
       return await this.oracle.getTxGasParams({ legacySpeed: speed, bumpPercent });
     } catch (e) {
@@ -77,27 +135,23 @@ export abstract class TornadoFeeOracle implements ITornadoFeeOracle {
 
   /**
    * Estimate next block gas price
-   * @param {TxType} type Tornado transaction type (to select correct default bump percent)
+   * @param {LegacyGasPriceKey} [speed] Preferred transaction speed, if uses legacy gas (before EIP-1559)
-   * @param {LegacyGasPriceKey} speed Preferred transaction speed, if uses legacy gas (before EIP-1559)
+   * @param {number} [bumpPercent] Gas bump percent to prioritize transaction
-   * @param {number} bumpPercent Gas bump percent to prioritize transaction
+   * @returns {Promise<HexadecimalStringifiedNumber>} Gas price in WEI (hex string)
-   * @returns {Promise<string>} Gas price in WEI (hex string)
    */
-  async getGasPrice(
+  async getGasPrice(speed?: LegacyGasPriceKey, bumpPercent?: number): Promise<HexadecimalStringifiedNumber> {
-    type: TxType = 'other',
+    const gasPriceParams = await this.getGasPriceParams(speed, bumpPercent);
-    speed: LegacyGasPriceKey = 'fast',
-    bumpPercent: number = 0,
-  ): Promise<string> {
-    const gasPriceParams = await this.getGasPriceParams(type, speed, bumpPercent);
     return calculateGasPriceInWei(gasPriceParams).toHexString();
   }
 
   /**
    * Estimates gas limit for transaction (or basic gas limit, if no tx data provided)
-   * @param {TransactionData} tx Transaction data (object in web3 / ethers format)
+   * @param {TransactionData} [tx] Transaction data (object in web3 / ethers format)
-   * @param {TxType} type Tornado transaction type: withdrawal by user, withdrawal by relayer, relayer fee check or 'other'
+   * @param {TxType} [type] Tornado transaction type: withdrawal by user, withdrawal by relayer, relayer fee check or 'other'
+   * @param {number} [bumpPercent] Gas bump percent to prioritize transaction
    * @returns {Promise<number>} Gas limit
    */
-  abstract getGasLimit(tx?: TransactionData, type?: TxType): Promise<number>;
+  abstract getGasLimit(tx?: TransactionData, type?: TxType, bumpPercent?: number): Promise<number>;
 
   /**
    * If user withdraw non-native tokens on ETH or Goerli, we need to calculate refund value:
@@ -105,60 +159,107 @@ export abstract class TornadoFeeOracle implements ITornadoFeeOracle {
    * and if the relayer pays a commission and the transfer of tokens fails, this commission will remain to the relayer.
    *
    * Refund needed that recipient can use tokens after withdrawal (covers gas fee for send/swap)
-   * @param {TransactionData} [tx] Transaction data (object in web3 / ethers format)
+   * @param {BigNumberish} gasPrice Actual gas price
-   * @returns {Promise<string>} Refund amount in WEI (hexed number)
+   * @param {InstanceTokenSymbol} tokenSymbol Withdrawal token (currency) symbol - for example, 'dai'
+   * @returns {HexadecimalStringifiedNumber} Refund amount in WEI (in hex format)
    */
-  async calculateRefundInETH(tx?: TransactionData): Promise<string> {
+  calculateRefundInETH(gasPrice: BigNumberish, tokenSymbol: InstanceTokenSymbol): HexadecimalStringifiedNumber {
+    // Refund only available for non-native tokens on Ethereum Mainnet and Goerli
+    if (![ChainId.MAINNET, ChainId.GOERLI].includes(this.chainId) || (tokenSymbol as AvailableTokenSymbols) === 'eth')
+      return '0';
+
+    // Notify user about error if incorrect token symbol provided
+    if (!Object.values(InstanceTokenSymbol).includes(tokenSymbol)) {
+      console.error(
+        `Invalid token symbol: ${tokenSymbol}, must be lowercase token from one of Tornado ETH Mainnet pools`,
+      );
+      return '0';
+    }
+
     // In Tornado we need to calculate refund only on user side, relayer get refund value in proof
-    const gas = await this.getGas(tx, 'user_withdrawal');
+    const gasLimit = defaultInstanceTokensGasLimit[tokenSymbol];
-    return BigNumber.from(gas).mul(2).toHexString();
+    return BigNumber.from(gasPrice).mul(gasLimit).mul(2).toHexString();
+  }
+
+  /**
+   * Fetched actual gas price and calculates refund amount
+   * @param {InstanceTokenSymbol} tokenSymbol Withdrawal token (currency) symbol - for example, 'dai'
+   * @returns {Promise<HexadecimalStringifiedNumber>} Refund amount in WEI (in hex format)
+   */
+  async fetchRefundInETH(tokenSymbol: InstanceTokenSymbol): Promise<HexadecimalStringifiedNumber> {
+    const gasPrice = await this.getGasPrice();
+    return this.calculateRefundInETH(gasPrice, tokenSymbol);
   }
 
   /**
    * Get refund amount on ETH or Goerli in non-native token
-   * @param {BigNumberish} tokenPriceInEth Token price in WEI in native currency
+   * @param {BigNumberish} gasPrice Actual gas price in ETH
-   * @param {string | number} tokenDecimals Token (currency) decimals
+   * @param {BigNumberish} tokenPriceInEth Token price in WEI in ETH
-   * @param {TransactionData} [tx] Transaction data (object in web3 / ethers format)
+   * @param {HexadecimalStringifiedNumber | number} tokenDecimals Token (currency) decimals
-   * @returns {Promise<string>} Refund amount in WEI in selected token (hexed number)
+   * @param {InstanceTokenSymbol} tokenSymbol Withdrawal token (currency) symbol - for example, 'dai'
+   * @returns {HexadecimalStringifiedNumber} Refund amount in WEI in selected token (hexed number)
    */
-  async calculateRefundInToken(
+  calculateRefundInToken(
+    gasPrice: BigNumberish,
     tokenPriceInEth: BigNumberish,
-    tokenDecimals: string | number,
+    tokenDecimals: HexadecimalStringifiedNumber | number,
-    tx?: TransactionData,
+    tokenSymbol: InstanceTokenSymbol,
-  ): Promise<string> {
+  ): HexadecimalStringifiedNumber {
-    const refundInEth = await this.calculateRefundInETH(tx);
+    const refundInEth = this.calculateRefundInETH(gasPrice, tokenSymbol);
     return convertETHToToken(refundInEth, tokenDecimals, tokenPriceInEth).toHexString();
   }
 
+  /**
+   * Calculates relayer fee in selected currency (ETH, DAI, BNB etc) in WEI
+   * @param {number | string} relayerFeePercent Relayer percent (0.4 for ETH Mainnet, for example)
+   * @param {HexadecimalStringifiedNumber | number} amount Amount in selected currency (10 for 10 ETH, 1000 for 1000 DAI)
+   * @param {string | number} decimals Decimal places in selected token (currency)
+   * @returns {HexadecimalStringifiedNumber} Fee in WEI (hexed stingified number)
+   */
+  calculateRelayerFeeInWei(
+    relayerFeePercent: number | string,
+    amount: HexadecimalStringifiedNumber | number,
+    decimals: string | number,
+  ): HexadecimalStringifiedNumber {
+    return parseUnits(amount.toString(), decimals)
+      .mul(`${Math.floor(Number(relayerFeePercent) * 1e10)}`)
+      .div(`${100 * 1e10}`)
+      .toHexString();
+  }
+
   /**
    * Estimates fee for withdrawal via relayer depending on type: gas bump percent is bigger, if it calculates by user,
    * so that the real commission from the relayer side is a little less,
    * in order to the relayer can send a transaction without fear that he will go into the red
-   * @param {TxType} type Tornado transaction type: withdrawal costs calculation from user side or from relayer side
+   * @param {GetWithdrawalFeeViaRelayerInput} params Function input arguments object
-   * @param {TransactionData} tx Transaction data (object in web3 / ethers format)
+   * @param {TxType} params.txType Tornado transaction type: withdrawal costs calculation from user side or from relayer side
-   * @param {number} relayerFeePercent Relayer fee percent from the transaction amount (for example, 0.15 for BNB or 0.4 for ETH Mainnet)
+   * @param {TransactionData} [params.tx] Transaction data (object in web3 / ethers format)
-   * @param {AvailableTokenSymbols | Uppercase<AvailableTokenSymbols>} currency Currency symbol
+   * @param {number} params.relayerFeePercent Relayer fee percent from the transaction amount (for example, 0.15 for BNB or 0.4 for ETH Mainnet)
-   * @param {number | string } amount Withdrawal amount in selected currency
+   * @param {AvailableTokenSymbols | Uppercase<AvailableTokenSymbols>} params.currency Currency symbol
-   * @param {number | string } decimals Token (currency) decimals
+   * @param {number | HexadecimalStringifiedNumber } params.amount Withdrawal amount in selected currency
-   * @param {BigNumberish} [refund=0] Refund in ETH, if withdrawed other tokens on Mainnet (not ETH)
+   * @param {number | HexadecimalStringifiedNumber } params.decimals Token (currency) decimals
-   * @param {BigNumberish} [tokenPriceInEth] If withdrawing other token on Mainnet or Goerli, need to provide token price in ETH (in WEI)
+   * @param {BigNumberish} [params.refundInEth] Refund in ETH, if withdrawed other tokens on Mainnet (not ETH). Can not be provided, if user-side calculation
-   * @returns {Promise<string>} Fee in WEI (hexed string)
+   * @param {BigNumberish} [params.tokenPriceInEth] If withdrawing other token on Mainnet or Goerli, need to provide token price in ETH (in WEI)
+   * @param {number} [params.gasLimit] Predefined gas limit, if already calculated (no refetching)
+   * @param {number} [params.gasPrice] Predefined gas price, if already calculated (no refetching)
+   *
+   * @returns {Promise<HexadecimalStringifiedNumber>} Fee in WEI (hexed string)
    */
-  async calculateWithdrawalFeeViaRelayer(
+  async calculateWithdrawalFeeViaRelayer({
-    type: TxType,
+    tx,
-    tx: TransactionData,
+    txType,
-    relayerFeePercent: number,
+    relayerFeePercent,
-    currency: AvailableTokenSymbols | Uppercase<AvailableTokenSymbols>,
+    currency,
-    amount: string | number,
+    amount,
-    decimals: string | number,
+    decimals,
-    refund: BigNumberish = 0,
+    refundInEth,
-    tokenPriceInEth?: BigNumberish,
+    tokenPriceInEth,
-  ): Promise<string> {
+    predefinedGasLimit,
-    const gasCosts = BigNumber.from(await this.getGas(tx, type));
+    predefinedGasPrice,
-
+  }: GetWithdrawalFeeViaRelayerInput): Promise<HexadecimalStringifiedNumber> {
-    const relayerFee = parseUnits(amount.toString(), decimals)
+    const relayerFee = this.calculateRelayerFeeInWei(relayerFeePercent, amount, decimals);
-      .mul(`${relayerFeePercent * 1e10}`)
+    const { gasPrice, gasLimit } = await this.getGasParams({ tx, txType, predefinedGasLimit, predefinedGasPrice });
-      .div(`${100 * 1e10}`);
+    const gasCosts = BigNumber.from(gasPrice).mul(gasLimit);
 
     if ((this.chainId === ChainId.MAINNET || this.chainId === ChainId.GOERLI) && currency.toLowerCase() != 'eth') {
       if (!tokenPriceInEth) {
@@ -166,10 +267,13 @@ export abstract class TornadoFeeOracle implements ITornadoFeeOracle {
         return '0';
       }
 
-      const feeInEth = gasCosts.add(refund);
+      if (txType === 'user_withdrawal' && refundInEth === undefined)
+        refundInEth = this.calculateRefundInETH(gasPrice, currency.toLowerCase() as InstanceTokenSymbol);
+
+      const feeInEth = BigNumber.from(gasCosts).add(refundInEth || 0);
       return convertETHToToken(feeInEth, decimals, tokenPriceInEth).add(relayerFee).toHexString();
     }
 
-    return gasCosts.add(relayerFee).toHexString();
+    return BigNumber.from(gasCosts).add(relayerFee).toHexString();
   }
 }

src/feeOracleV4.ts

@@ -2,9 +2,11 @@ import { defaultWithdrawalGasLimit } from './config';
 import { TornadoFeeOracle } from './feeOracle';
 import { ITornadoFeeOracle, TransactionData, TxType, LegacyGasPrices } from './types';
 import { GasPriceOracle } from '@tornado/gas-price-oracle';
-import { BigNumber } from 'ethers';
 import { bump } from './utils';
 
+/**
+ * Oracle for V4 (old-version) transactions - estimates fee with predefined gas limit and without smart bumping
+ */
 export class TornadoFeeOracleV4 extends TornadoFeeOracle implements ITornadoFeeOracle {
   public constructor(chainId: number, rpcUrl: string, defaultGasPrices?: LegacyGasPrices) {
     const oracleConfig = {
@@ -14,11 +16,11 @@ export class TornadoFeeOracleV4 extends TornadoFeeOracle implements ITornadoFeeO
     };
     const gasPriceOracle = new GasPriceOracle(oracleConfig);
 
-    super(chainId, rpcUrl, gasPriceOracle);
+    super(4, chainId, rpcUrl, gasPriceOracle);
   }
 
-  async getGasLimit(tx?: TransactionData, type: TxType = 'other', bumpPercent?: number): Promise<number> {
+  async getGasLimit(tx?: TransactionData, type: TxType = 'other', bumpPercent: number = 0): Promise<number> {
-    if (type === 'user_withdrawal') return BigNumber.from(defaultWithdrawalGasLimit[this.chainId]).toNumber();
+    if (type === 'user_withdrawal') return bump(defaultWithdrawalGasLimit[this.chainId], bumpPercent).toNumber();
 
     // Need to bump relayer gas limit for transaction, because predefined gas limit to small to be 100% sure that transaction will be sent
     // This leads to fact that relayer often pays extra for gas from his own funds, however, this was designed by previous developers
@@ -27,8 +29,8 @@ export class TornadoFeeOracleV4 extends TornadoFeeOracle implements ITornadoFeeO
     // For compatibility reasons, when wee check user-provided fee for V4 withdrawal transaction, we need dump gas limit
     // for about 20 percent,so that the transaction will be sent, even if it results in some loss for the relayer
     if (type === 'relayer_withdrawal_check_v4') return bump(defaultWithdrawalGasLimit[this.chainId], -25).toNumber();
-    if (!tx) return 21_000;
+    if (!tx || Object.keys(tx).length === 0) return bump(23_000, bumpPercent).toNumber();
 
-    return (await this.provider.estimateGas(tx)).toNumber();
+    return bump(await this.provider.estimateGas(tx), bumpPercent).toNumber();
   }
 }

src/feeOracleV5.ts

@@ -12,6 +12,9 @@ import { GasPriceOracle } from '@tornado/gas-price-oracle';
 import { bump } from './utils';
 import { TornadoFeeOracleV4 } from './feeOracleV4';
 
+/**
+ * Oracle for new V5 version - estimates transaction fees with smart gas limit & bumping
+ */
 export class TornadoFeeOracleV5 extends TornadoFeeOracle implements ITornadoFeeOracle {
   private fallbackFeeOracle: TornadoFeeOracleV4;
 
@@ -19,14 +22,14 @@ export class TornadoFeeOracleV5 extends TornadoFeeOracle implements ITornadoFeeO
     const oracleConfig = {
       chainId,
       defaultRpc: rpcUrl,
-      minPriority: chainId === 1 || chainId === 5 ? 2 : 0.05,
+      minPriority: chainId === ChainId.MAINNET || chainId === ChainId.GOERLI ? 2 : chainId === ChainId.BSC ? 3 : 0.05,
       percentile: 5,
       blocksCount: 20,
       defaultFallbackGasPrices: defaultGasPrices,
     };
     const gasPriceOracle = new GasPriceOracle(oracleConfig);
 
-    super(chainId, rpcUrl, gasPriceOracle);
+    super(5, chainId, rpcUrl, gasPriceOracle);
 
     this.fallbackFeeOracle = new TornadoFeeOracleV4(chainId, rpcUrl, defaultGasPrices);
   }
@@ -49,16 +52,12 @@ export class TornadoFeeOracleV5 extends TornadoFeeOracle implements ITornadoFeeO
     }
   }
 
-  async getGasPriceParams(
+  async getGasPriceParams(speed?: LegacyGasPriceKey, bumpPercent?: number): Promise<GasPriceParams> {
-    type: TxType = 'other',
-    speed: LegacyGasPriceKey = 'fast',
-    bumpPercent?: number,
-  ): Promise<GasPriceParams> {
     // Only if bump percent didn't provided (if user provides 0, no need to recalculate)
     if (bumpPercent === undefined) {
       switch (this.chainId) {
         case ChainId.GOERLI:
-          bumpPercent = type === 'user_withdrawal' ? 100 : 50;
+          bumpPercent = 100;
           break;
         case ChainId.POLYGON:
         case ChainId.AVAX:
@@ -70,6 +69,6 @@ export class TornadoFeeOracleV5 extends TornadoFeeOracle implements ITornadoFeeO
       }
     }
 
-    return super.getGasPriceParams(type, speed, bumpPercent);
+    return super.getGasPriceParams(speed, bumpPercent);
   }
 }

src/tokenPriceOracle.ts

@@ -40,9 +40,10 @@ export class TokenPriceOracle implements ITornadoPriceOracle {
   private provider: Provider;
 
   /**
-   *
+   * Constructs TokenPriceOracle class instance
-   * @param rpcUrl
+   * @param {string} rpcUrl http RPC (Ethereum Mainnet) url to fetch token prices from contract
-   * @param tokens
+   * @param {Token[]} [tokens] Array of tokens
+   * @param {TokenPrices} [defaultTokenPrices] Default token prices, fallback if nothing loaded from contract
    */
   constructor(
     rpcUrl: string,
@@ -61,7 +62,7 @@ export class TokenPriceOracle implements ITornadoPriceOracle {
 
   /**
    * Prepare data for MultiCall contract
-   * @param {Token[]} tokens Tokens array
+   * @param {Token[]} [tokens] Tokens array
    * @returns Valid structure to provide to MultiCall contract
    */
   private prepareCallData(tokens: Token[] = this.tokens): MultiCall.CallStruct[] {
@@ -73,7 +74,7 @@ export class TokenPriceOracle implements ITornadoPriceOracle {
 
   /**
    * Fetch actual tokens price rate to ETH from offchain oracles
-   * @param {Token[]} tokens Token array
+   * @param {Token[]} [tokens] Token array
    * @returns {TokenPrices} Object with token price rate to ETH in WEI
    */
   async fetchPrices(tokens: Token[] = this.tokens): Promise<TokenPrices> {

src/types.ts

@@ -1,6 +1,10 @@
 import { BigNumberish, BytesLike } from 'ethers';
 import { GasPriceKey, GetTxGasParamsRes } from '@tornado/gas-price-oracle/lib/services';
 import { AvailableTokenSymbols } from '@tornado/tornado-config';
+import { InstanceTokenSymbol } from './config';
+
+// Type for big hexadecimal numbers, like 0x1eff87f47e37a0
+export type HexadecimalStringifiedNumber = string;
 
 export type LegacyGasPriceKey = GasPriceKey;
 export type GasPriceParams = GetTxGasParamsRes;
@@ -14,7 +18,8 @@ export type LegacyGasPrices = {
   - 'relayer_withdrawal_check_v4' - Fee calculation on relayer side, when V4 relayer checks user-provided fee. For compatibility reasons
   - 'other' - Any other non-specific transaction
 */
-export type TxType = 'user_withdrawal' | 'relayer_withdrawal' | 'relayer_withdrawal_check_v4' | 'other';
+export type WithdrawalTxType = 'user_withdrawal' | 'relayer_withdrawal' | 'relayer_withdrawal_check_v4';
+export type TxType = WithdrawalTxType | 'other';
 
 export interface TransactionData {
   to: string;
@@ -31,26 +36,21 @@ export interface TransactionData {
 }
 
 export interface ITornadoFeeOracle {
-  getGas: (tx?: TransactionData, type?: TxType) => Promise<string>;
+  getGasParams: (params?: GetGasParamsInput) => Promise<GetGasParamsRes>;
-  getGasPriceParams: (type?: TxType, speed?: LegacyGasPriceKey, bumpPercent?: number) => Promise<GasPriceParams>;
+  getGas: (params?: GetGasInput) => Promise<HexadecimalStringifiedNumber>;
-  getGasPrice: (type?: TxType, speed?: LegacyGasPriceKey, bumpPercent?: number) => Promise<string>;
+  getGasPriceParams: (speed?: LegacyGasPriceKey, bumpPercent?: number) => Promise<GasPriceParams>;
+  getGasPrice: (speed?: LegacyGasPriceKey, bumpPercent?: number) => Promise<HexadecimalStringifiedNumber>;
   getGasLimit: (tx?: TransactionData, type?: TxType, bumpPercent?: number) => Promise<number>;
-  calculateRefundInETH: (tx?: TransactionData) => Promise<string>;
+  fetchL1OptimismFee: (tx?: TransactionData) => Promise<HexadecimalStringifiedNumber>;
+  calculateRefundInETH: (gasPrice: BigNumberish, tokenSymbol: InstanceTokenSymbol) => HexadecimalStringifiedNumber;
+  fetchRefundInETH: (tokenSymbol: InstanceTokenSymbol) => Promise<HexadecimalStringifiedNumber>;
   calculateRefundInToken: (
+    gasPrice: BigNumberish,
     tokenPriceInEth: BigNumberish,
-    tokenDecimals: string | number,
+    tokenDecimals: HexadecimalStringifiedNumber | number,
-    tx?: TransactionData,
+    tokenSymbol: InstanceTokenSymbol,
-  ) => Promise<string>;
+  ) => HexadecimalStringifiedNumber;
-  calculateWithdrawalFeeViaRelayer: (
+  calculateWithdrawalFeeViaRelayer: (params: GetWithdrawalFeeViaRelayerInput) => Promise<HexadecimalStringifiedNumber>;
-    type: TxType,
-    tx: TransactionData,
-    relayerFeePercent: number,
-    currency: AvailableTokenSymbols,
-    amount: string,
-    decimals: number,
-    refund: BigNumberish,
-    tokenPriceInEth?: BigNumberish,
-  ) => Promise<string>;
 }
 
 export interface ITornadoPriceOracle {
@@ -77,3 +77,38 @@ export type Token = {
   decimals: number;
 };
 export type TokenPrices = { [tokenSymbol in TokenSymbol]?: BigNumberish };
+
+// Reponse type for getGasParams function of fee oracle
+export type GetGasParamsRes = {
+  gasLimit: number;
+  gasPrice: HexadecimalStringifiedNumber; // Gas price in native currency
+};
+
+export type GetGasInput = {
+  // Transaction type: user-side calculation, relayer-side calculation or
+  // relayer calculation to check user-provided fee in old V4 relayer (for backwards compatibility)
+  txType?: TxType;
+  tx?: TransactionData; // Transaction data in ethers format
+  predefinedGasPrice?: HexadecimalStringifiedNumber; // Predefined gas price for withdrawal tx (wont be calculated again in function)
+  predefinedGasLimit?: number; // Predefined gas limit for withdrawal tx (wont be calculated again in function)
+  bumpGasLimitPercent?: number; // Gas limit bump percent to prioritize transaction (recenlty used)
+  bumpGasPricePercent?: number; // Gas price bump percent to prioritize transaction (rarely used)
+  speed?: LegacyGasPriceKey; // Preferred transaction speed, if uses legacy gas (before EIP-1559)
+};
+
+export type GetGasParamsInput = GetGasInput & { includeL1FeeToGasLimit?: boolean };
+
+export type GetWithdrawalFeeViaRelayerInput = {
+  // Transaction type: user-side calculation, relayer-side calculation or
+  // relayer calculation to check user-provided fee in old V4 relayer (for backwards compatibility)
+  txType: WithdrawalTxType;
+  tx?: TransactionData; // Transaction data in ethers format
+  relayerFeePercent: number | string; // Relayer fee percent from withdrawal amount (for example, 0.15 for BNB or 0.4 for ETH Mainnet)
+  currency: AvailableTokenSymbols | Uppercase<AvailableTokenSymbols>; // Currency (token) symbol
+  amount: string | number; // Withdrawal amount in selected currency (10 for 10 ETH, 10000 for 10000 DAI)
+  decimals: string | number; // Token (currency) decimal places
+  refundInEth?: HexadecimalStringifiedNumber; // Refund amount in ETH, if withdrawing non-native currency on ETH Mainnet or Goerli
+  tokenPriceInEth?: HexadecimalStringifiedNumber | string; // Token (currency) price in ETH wei, if withdrawing non-native currency
+  predefinedGasPrice?: HexadecimalStringifiedNumber; // Predefined gas price for withdrawal tx (wont be calculated again in function)
+  predefinedGasLimit?: number; // Predefined gas limit for withdrawal tx (wont be calculated again in function)
+};

src/utils.ts

@@ -25,6 +25,7 @@ export function bump(value: BigNumberish, percent: number): BigNumber {
     BigNumberFloat(BigNumber.from(value).toHexString())
       .times(hundredPercents.plus(BigNumberFloat(percent)))
       .div(hundredPercents)
+      .decimalPlaces(0, 1)
       .toString(),
   );
 }