fix: update dependencies

Bumps [axios](https://github.com/axios/axios) from 0.19.2 to 0.21.2.
- [Release notes](https://github.com/axios/axios/releases)
- [Changelog](https://github.com/axios/axios/blob/master/CHANGELOG.md)
- [Commits](https://github.com/axios/axios/compare/v0.19.2...v0.21.2)

---
updated-dependencies:
- dependency-name: axios
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

.eslintrc.js

@@ -0,0 +1,17 @@
+module.exports = {
+  parser: '@typescript-eslint/parser', // Specifies the ESLint parser
+  parserOptions: {
+    ecmaVersion: 2020, // Allows for the parsing of modern ECMAScript features
+    sourceType: 'module', // Allows for the use of imports
+  },
+  extends: [
+    'plugin:@typescript-eslint/recommended', // Uses the recommended rules from the @typescript-eslint/eslint-plugin
+    'prettier/@typescript-eslint', // Uses eslint-config-prettier to disable ESLint rules from @typescript-eslint/eslint-plugin that would conflict with prettier
+    'plugin:prettier/recommended', // Enables eslint-plugin-prettier and eslint-config-prettier. This will display prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
+  ],
+  rules: {
+    indent: ['error', 2],
+    // Place to specify ESLint rules. Can be used to overwrite rules specified from the extended configs
+    // e.g. "@typescript-eslint/explicit-function-return-type": "off",
+  },
+};

.github/workflows/nodejs.yml

@@ -0,0 +1,61 @@
+name: Node.js CI
+
+on:
+  push:
+    branches: ['*']
+    tags: ['v[0-9]+.[0-9]+.[0-9]+']
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12
+      - run: yarn install --frozen-lockfile
+      - run: yarn test
+      - run: yarn lint
+
+  publish:
+    runs-on: ubuntu-latest
+    needs: [build]
+    if: startsWith(github.ref, 'refs/tags')
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - run: yarn install
+      - run: yarn run build
+      - name: NPM login
+        # NPM doesn't understand env vars and needs auth file lol
+        run: echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Set vars
+        id: vars
+        run: |
+          echo "::set-output name=version::$(echo ${GITHUB_REF#refs/tags/v})"
+          echo "::set-output name=repo_name::$(echo ${GITHUB_REPOSITORY#*/})"
+      - name: Check package.json version vs tag
+        run: |
+          [ ${{ steps.vars.outputs.version }} = $(grep '"version":' package.json | grep -o "[0-9.]*") ] || (echo "Git tag doesn't match version in package.json" && false)
+      - name: Publish to npm
+        run: npm publish
+      - name: Create GitHub Release Draft
+        uses: actions/create-release@v1
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ steps.vars.outputs.version }}
+          draft: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Telegram Message Notify
+        uses: appleboy/telegram-action@0.0.7
+        with:
+          to: ${{ secrets.TELEGRAM_CHAT_ID }}
+          token: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+          message: 🚀 Published [${{ steps.vars.outputs.repo_name }}](https://github.com/${{ github.repository }}) version [${{ steps.vars.outputs.version }}](https://www.npmjs.com/package/${{ steps.vars.outputs.repo_name }}/v/${{ steps.vars.outputs.version }}) to npm
+          debug: true
+          format: markdown

.prettierrc

@@ -0,0 +1,8 @@
+{
+  "semi": true,
+  "trailingComma": "all",
+  "singleQuote": true,
+  "printWidth": 110,
+  "tabWidth": 2,
+  "arrowParens": "avoid"
+}

.vscode/launch.json

@@ -1,24 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Mocha Current File",
-            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
-            "args": [
-              "--no-timeouts",
-              "--colors",
-              "${file}",
-              "--require",
-              "ts-node/register"
-            ],
-            "console": "integratedTerminal",
-            "sourceMaps": true,
-            "internalConsoleOptions": "neverOpen"
-      }
-    ]
-}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 PepperSec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,48 +1,122 @@
-# Gas Price Oracle library for Ethereum dApps
+# Gas Price Oracle library for Ethereum dApps [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/peppersec/gas-price-oracle/Node.js%20CI)](https://github.com/peppersec/gas-price-oracle/actions) [![npm](https://img.shields.io/npm/v/gas-price-oracle)](https://www.npmjs.com/package/gas-price-oracle)
+
+A library that has a collection of onchain and offchain gas price oracle URLs
+
+## Supported networks
+
+### Ethereum Mainnet
+
+Current offchain list:
+
+- https://ethgasstation.info/json/ethgasAPI.json
+- https://etherchain.org/api/gasnow
+- https://blockscout.com/eth/mainnet/api/v1/gas-price-oracle
+
+Current onchain list:
+
+- [chainlink](https://etherscan.io/address/0x169e633a2d1e6c10dd91238ba11c4a708dfef37c#readContract)
+
+### Binance Smart Chain
+
+Current offchain list:
+
+- https://ztake.org/
+
+### xDAI Chain
+
+Current offchain list:
+
+- https://blockscout.com/xdai/mainnet/api/v1/gas-price-oracle
+
+### Polygon (Matic) Network
+
+Current offchain list:
+
+- https://gasstation-mainnet.matic.network/
+
+### Arbitrum One
+
+Current offchain list:
+
+- https://ztake.org/
+
+### Avalanche Mainnet
+
+Current offchain list:
+
+- https://ztake.org/
+
+## Installation
 
-## Instalation
 `npm i gas-price-oracle`
 
 ## Import
+
 ```js
 const { GasPriceOracle } = require('gas-price-oracle');
 ```
-## Usage
-### Basic
-```js
-const oracle = new GasPriceOracle();
 
-oracle.gasPrices().then((gas) => {
-    console.log(gas)
+## Usage
+
+### Basic
+
+```js
+const options = {
+  chainId: 1,
+  defaultRpc: 'https://api.mycryptoapi.com/eth',
+  timeout: 10000,
+  defaultFallbackGasPrices: {
+    instant: 28,
+    fast: 22,
+    standard: 17,
+    low: 11,
+  },
+};
+const oracle = new GasPriceOracle(options);
+// optional fallbackGasPrices
+const fallbackGasPrices = {
+  instant: 70,
+  fast: 31,
+  standard: 20,
+  low: 7,
+};
+oracle.gasPrices(fallbackGasPrices).then(gasPrices => {
+  console.log(gasPrices); // { instant: 50, fast: 21, standard: 10, low: 3 }
 });
 ```
 
+The `gasPrices` method also accepts `median` argument (`true`) by default. For more details see [below](#offchain-oracles-only-get-median-price).
+Under the hood it's a combination of `fetchMedianGasPriceOffChain`(`fetchGasPricesOffChain`) and `fetchGasPricesOnChain` methods.
+
 ### Offchain oracles only
+
 ```js
 const oracle = new GasPriceOracle();
 
-oracle.fetchGasPricesOffChain().then((gas) => {
-    console.log(gas)
+oracle.fetchGasPricesOffChain().then(gasPrices => {
+  console.log(gasPrices); // { instant: 50, fast: 21, standard: 10, low: 3 }
 });
 ```
 
+### Offchain oracles only (get median price)
+
+```js
+const oracle = new GasPriceOracle();
+
+oracle.fetchMedianGasPriceOffChain().then(gasPrices => {
+  console.log(gasPrices); // { instant: 50, fast: 21, standard: 10, low: 3 }
+});
+```
+
+it returns the median gas price of all the oracles configured.
+
 ### Custom RPC URL for onchain oracles
-```js
-const customRpc = 'https://mainnet.infura.io/v3/<API_KEY>'
-const oracle = new GasPriceOracle(customRpc);
 
-oracle.fetchGasPricesOnChain().then((gas) => {
-    console.log(gas)
-});
-```
-
-### Don't throw an error if oracles are down
-```js
-oracle.fetchGasPricesOnChain(false).then((gas) => {
-    console.log(gas)
-});
-
-oracle.fetchGasPricesOffChain(false).then((gas) => {
-    console.log(gas)
+```js
+const defaultRpc = 'https://mainnet.infura.io/v3/<API_KEY>';
+const oracle = new GasPriceOracle({ defaultRpc });
+
+oracle.fetchGasPricesOnChain().then(gasPrices => {
+  console.log(gasPrices); // 21
 });
 ```

package.json

@@ -1,37 +1,54 @@
 {
   "name": "gas-price-oracle",
-  "version": "0.1.1",
+  "version": "0.4.2",
   "description": "Gas Price Oracle library for Ethereum dApps.",
   "main": "lib/index.js",
+  "homepage": "https://github.com/peppersec/gas-price-oracle",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/peppersec/gas-price-oracle.git"
+  },
   "types": "lib/index.d.ts",
   "prepare": "npm run build",
   "prepublishOnly": "npm test && npm run lint",
   "scripts": {
-    "test": "mocha --timeout 30000 -r ts-node/register tests/*.test.ts",
+    "test": "mocha -r ts-node/register --timeout 30000 --exit src tests/*.test.ts",
     "build": "tsc",
-    "lint": "tslint -p tsconfig.json"
+    "eslint": "eslint 'src/*.ts'",
+    "prettier:check": "prettier --check . --config .prettierrc",
+    "prettier:fix": "prettier --write . --config .prettierrc",
+    "lint": "yarn eslint && yarn prettier:check"
   },
   "author": "Alexey Pertsev <alexey@peppersec.com> (https://peppersec.com)",
-  "keywords": ["Gas", "Gas price", "Ethereum", "Oracle"],
+  "keywords": [
+    "Gas",
+    "Gas price",
+    "Ethereum",
+    "Oracle"
+  ],
   "license": "MIT",
   "devDependencies": {
     "@types/chai": "^4.2.11",
+    "@types/chai-as-promised": "^7.1.3",
     "@types/mocha": "^7.0.2",
     "@types/mockery": "^1.4.29",
+    "@types/node": "^14.0.5",
+    "@typescript-eslint/eslint-plugin": "^4.4.1",
+    "@typescript-eslint/parser": "^4.4.1",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
+    "eslint": "^7.11.0",
+    "eslint-config-prettier": "^6.13.0",
+    "eslint-plugin-prettier": "^3.1.4",
     "mocha": "^7.2.0",
     "mockery": "^2.1.0",
-    "tslint": "^6.1.2",
-    "tslint-config-standard": "^9.0.0"
+    "prettier": "^2.1.2",
+    "ts-node": "^8.10.1",
+    "typescript": "^4.0.3"
   },
   "dependencies": {
-    "@types/node": "^14.0.5",
-    "@types/node-fetch": "^2.5.7",
-    "bignumber.js": "^9.0.0",
-    "node-fetch": "^2.6.0",
-    "ts-node": "^8.10.1",
-    "typescript": "^3.9.3"
+    "axios": "^0.21.2",
+    "bignumber.js": "^9.0.0"
   },
   "files": [
     "lib/**/*"

src/config.ts

@@ -1,62 +0,0 @@
-
-import { OffChainOracle, OnChainOracle } from './types';
-
-const ethgasstation: OffChainOracle = {
-  name: 'ethgasstation',
-  url: 'https://ethgasstation.info/json/ethgasAPI.json',
-  instantPropertyName: 'fastest',
-  fastPropertyName: 'fast',
-  standardPropertyName: 'average',
-  lowPropertyName: 'safeLow',
-  denominator: 10
-};
-
-const zoltu: OffChainOracle = {
-  name: 'zoltu',
-  url: 'https://gas-oracle.zoltu.io/',
-  instantPropertyName: 'percentile_99',
-  fastPropertyName: 'percentile_90',
-  standardPropertyName: 'percentile_60',
-  lowPropertyName: 'percentile_30',
-  denominator: 1
-};
-
-const etherchain: OffChainOracle = {
-  name: 'etherchain',
-  url: 'https://www.etherchain.org/api/gasPriceOracle',
-  instantPropertyName: 'fastest',
-  fastPropertyName: 'fast',
-  standardPropertyName: 'standard',
-  lowPropertyName: 'safeLow',
-  denominator: 1
-};
-
-const poa: OffChainOracle = {
-  name: 'poa',
-  url: 'https://gasprice.poa.network/',
-  instantPropertyName: 'instant',
-  fastPropertyName: 'fast',
-  standardPropertyName: 'standard',
-  lowPropertyName: 'slow',
-  denominator: 1
-};
-
-const chainlink: OnChainOracle = {
-  name: 'chainlink',
-  callData: '0x50d25bcd',
-  contract: '0xA417221ef64b1549575C977764E651c9FAB50141',
-  denominator: '1000000000'
-};
-
-export const offChainOracles: { [key: string]: OffChainOracle } = {
-  ethgasstation, zoltu, poa, etherchain
-};
-
-export const onChainOracles: { [key: string]: OnChainOracle } = {
-  chainlink
-};
-
-export default {
-  offChainOracles,
-  onChainOracles
-};

src/config/arbitrum.ts

@@ -0,0 +1,23 @@
+import { OffChainOracle, OffChainOracles, OnChainOracles } from '../types';
+
+const ztake: OffChainOracle = {
+  name: 'ztake',
+  url: 'https://blockchains.ztake.org/api/h6WnmwNqw9CAJHzej5W4gD6LZ9n7v8EK/gasprice/arb/',
+  instantPropertyName: 'percentile_90',
+  fastPropertyName: 'percentile_80',
+  standardPropertyName: 'percentile_60',
+  lowPropertyName: 'percentile_30',
+  denominator: 1,
+  additionalDataProperty: null,
+};
+
+export const offChainOracles: OffChainOracles = {
+  ztake,
+};
+
+export const onChainOracles: OnChainOracles = {};
+
+export default {
+  offChainOracles,
+  onChainOracles,
+};

src/config/avalanche.ts

@@ -0,0 +1,23 @@
+import { OffChainOracle, OffChainOracles, OnChainOracles } from '../types';
+
+const ztake: OffChainOracle = {
+  name: 'ztake',
+  url: 'https://blockchains.ztake.org/api/h6WnmwNqw9CAJHzej5W4gD6LZ9n7v8EK/gasprice/avax/',
+  instantPropertyName: 'percentile_90',
+  fastPropertyName: 'percentile_80',
+  standardPropertyName: 'percentile_60',
+  lowPropertyName: 'percentile_30',
+  denominator: 1,
+  additionalDataProperty: null,
+};
+
+export const offChainOracles: OffChainOracles = {
+  ztake,
+};
+
+export const onChainOracles: OnChainOracles = {};
+
+export default {
+  offChainOracles,
+  onChainOracles,
+};

src/config/bsc.ts

@@ -0,0 +1,23 @@
+import { OffChainOracle, OffChainOracles, OnChainOracles } from '../types';
+
+const ztake: OffChainOracle = {
+  name: 'ztake',
+  url: 'https://blockchains.ztake.org/api/h6WnmwNqw9CAJHzej5W4gD6LZ9n7v8EK/gasprice/bsc/',
+  instantPropertyName: 'percentile_90',
+  fastPropertyName: 'percentile_80',
+  standardPropertyName: 'percentile_60',
+  lowPropertyName: 'percentile_30',
+  denominator: 1,
+  additionalDataProperty: null,
+};
+
+export const offChainOracles: OffChainOracles = {
+  ztake,
+};
+
+export const onChainOracles: OnChainOracles = {};
+
+export default {
+  offChainOracles,
+  onChainOracles,
+};

src/config/index.ts

@@ -0,0 +1,26 @@
+import { NetworkConfig } from '../types';
+
+import mainnetOracles from './mainnet';
+import bscOracles from './bsc';
+import xdaiOracles from './xdai';
+import polygonOracles from './polygon';
+import arbitrumOracles from './arbitrum';
+import avalancheOracles from './avalanche';
+
+export enum ChainId {
+  MAINNET = 1,
+  BSC = 56,
+  XDAI = 100,
+  POLYGON = 137,
+  ARBITRUM = 42161,
+  AVALANCHE = 43114,
+}
+
+export const NETWORKS: NetworkConfig = {
+  [ChainId.MAINNET]: mainnetOracles,
+  [ChainId.BSC]: bscOracles,
+  [ChainId.XDAI]: xdaiOracles,
+  [ChainId.POLYGON]: polygonOracles,
+  [ChainId.ARBITRUM]: arbitrumOracles,
+  [ChainId.AVALANCHE]: avalancheOracles,
+};

src/config/mainnet.ts

@@ -0,0 +1,68 @@
+import { OffChainOracle, OnChainOracle, OffChainOracles, OnChainOracles } from '../types';
+
+const ethgasstation: OffChainOracle = {
+  name: 'ethgasstation',
+  url: 'https://ethgasstation.info/json/ethgasAPI.json',
+  instantPropertyName: 'fastest',
+  fastPropertyName: 'fast',
+  standardPropertyName: 'average',
+  lowPropertyName: 'safeLow',
+  denominator: 10,
+  additionalDataProperty: null,
+};
+
+const etherchain: OffChainOracle = {
+  name: 'etherchain',
+  url: 'https://etherchain.org/api/gasnow',
+  instantPropertyName: 'rapid',
+  fastPropertyName: 'fast',
+  standardPropertyName: 'standard',
+  lowPropertyName: 'slow',
+  denominator: 1,
+  additionalDataProperty: 'data',
+};
+
+const blockscout: OffChainOracle = {
+  name: 'blockscout',
+  url: 'https://blockscout.com/eth/mainnet/api/v1/gas-price-oracle',
+  instantPropertyName: 'fast',
+  fastPropertyName: 'average',
+  standardPropertyName: 'slow',
+  lowPropertyName: 'slow',
+  denominator: 1,
+  additionalDataProperty: null,
+};
+
+const anyblock: OffChainOracle = {
+  name: 'anyblock',
+  url: 'https://api.anyblock.tools/ethereum/latest-minimum-gasprice',
+  instantPropertyName: 'instant',
+  fastPropertyName: 'fast',
+  standardPropertyName: 'standard',
+  lowPropertyName: 'slow',
+  denominator: 1,
+  additionalDataProperty: null,
+};
+
+const chainlink: OnChainOracle = {
+  name: 'chainlink',
+  callData: '0x50d25bcd',
+  contract: '0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C',
+  denominator: '1000000000',
+};
+
+export const offChainOracles: OffChainOracles = {
+  ethgasstation,
+  anyblock,
+  blockscout,
+  etherchain,
+};
+
+export const onChainOracles: OnChainOracles = {
+  chainlink,
+};
+
+export default {
+  offChainOracles,
+  onChainOracles,
+};

src/config/polygon.ts

@@ -0,0 +1,23 @@
+import { OffChainOracle, OffChainOracles, OnChainOracles } from '../types';
+
+const maticGasStation: OffChainOracle = {
+  name: 'maticGasStation',
+  url: 'https://gasstation-mainnet.matic.network',
+  instantPropertyName: 'fastest',
+  fastPropertyName: 'fast',
+  standardPropertyName: 'standard',
+  lowPropertyName: 'safeLow',
+  denominator: 1,
+  additionalDataProperty: null,
+};
+
+export const offChainOracles: OffChainOracles = {
+  maticGasStation,
+};
+
+export const onChainOracles: OnChainOracles = {};
+
+export default {
+  offChainOracles,
+  onChainOracles,
+};

src/config/xdai.ts

@@ -0,0 +1,23 @@
+import { OffChainOracle, OffChainOracles, OnChainOracles } from '../types';
+
+const blockscout: OffChainOracle = {
+  name: 'blockscout',
+  url: 'https://blockscout.com/xdai/mainnet/api/v1/gas-price-oracle',
+  instantPropertyName: 'fast',
+  fastPropertyName: 'average',
+  standardPropertyName: 'slow',
+  lowPropertyName: 'slow',
+  denominator: 1,
+  additionalDataProperty: null,
+};
+
+export const offChainOracles: OffChainOracles = {
+  blockscout,
+};
+
+export const onChainOracles: OnChainOracles = {};
+
+export default {
+  offChainOracles,
+  onChainOracles,
+};

src/index.ts

@@ -1,134 +1,277 @@
-import fetch from 'node-fetch';
-import config from './config';
-import { GasPrice, OffChainOracle, OnChainOracle } from './types';
+import axios from 'axios';
 import BigNumber from 'bignumber.js';
 
+import { ChainId, NETWORKS } from './config';
+
+import {
+  Config,
+  Options,
+  GasPrice,
+  GasPriceKey,
+  OffChainOracle,
+  OnChainOracle,
+  OnChainOracles,
+  OffChainOracles,
+} from './types';
+
+const defaultFastGas = 22;
 export class GasPriceOracle {
-  lastGasPrice: GasPrice = {
-    instant: 40,
-    fast: 21,
-    standard: 10,
-    low: 1
+  lastGasPrice: GasPrice;
+  offChainOracles: OffChainOracles;
+  onChainOracles: OnChainOracles;
+  configuration: Config = {
+    chainId: ChainId.MAINNET,
+    defaultRpc: 'https://api.mycryptoapi.com/eth',
+    timeout: 10000,
+    defaultFallbackGasPrices: {
+      instant: defaultFastGas * 1.3,
+      fast: defaultFastGas,
+      standard: defaultFastGas * 0.85,
+      low: defaultFastGas * 0.5,
+    },
   };
-  defaultRpc = 'https://api.mycryptoapi.com/eth';
-  offChainOracles = { ...config.offChainOracles };
-  onChainOracles = { ...config.onChainOracles };
 
-  constructor(defaultRpc?: string) {
-    if (defaultRpc) {
-      this.defaultRpc = defaultRpc;
+  constructor(options?: Options) {
+    if (options) {
+      Object.assign(this.configuration, options);
+    }
+
+    const network = NETWORKS[this.configuration.chainId];
+
+    if (network) {
+      const { offChainOracles, onChainOracles } = network;
+      this.offChainOracles = { ...offChainOracles };
+      this.onChainOracles = { ...onChainOracles };
     }
   }
 
-  async fetchGasPricesOffChain(throwIfFailsToFetch = true): Promise<GasPrice> {
-    for (let oracle of Object.values(this.offChainOracles)) {
-      const { name, url, instantPropertyName, fastPropertyName, standardPropertyName, lowPropertyName, denominator } = oracle;
-      try {
-        const response = await fetch(url);
-        if (response.status === 200) {
-          const gas = await response.json();
-          if (Number(gas[fastPropertyName]) === 0) {
-            throw new Error(`${name} oracle provides corrupted values`);
-          }
-          const gasPrices: GasPrice = {
-            instant: parseFloat(gas[instantPropertyName]) / denominator,
-            fast: parseFloat(gas[fastPropertyName]) / denominator,
-            standard: parseFloat(gas[standardPropertyName]) / denominator,
-            low: parseFloat(gas[lowPropertyName]) / denominator
-          };
-          this.lastGasPrice = gasPrices;
-          return this.lastGasPrice;
-        } else {
-          throw new Error(`Fetch gasPrice from ${name} oracle failed. Trying another one...`);
-        }
-      } catch (e) {
-        console.error(e.message);
+  async askOracle(oracle: OffChainOracle): Promise<GasPrice> {
+    const {
+      name,
+      url,
+      instantPropertyName,
+      fastPropertyName,
+      standardPropertyName,
+      lowPropertyName,
+      denominator,
+      additionalDataProperty,
+    } = oracle;
+    const response = await axios.get(url, { timeout: this.configuration.timeout });
+    if (response.status === 200) {
+      const gas = additionalDataProperty ? response.data[additionalDataProperty] : response.data;
+      if (Number(gas[fastPropertyName]) === 0) {
+        throw new Error(`${name} oracle provides corrupted values`);
       }
-    }
-    if (throwIfFailsToFetch) {
-      throw new Error('All oracles are down. Probaly network error.');
-    }
-    return this.lastGasPrice;
-  }
-
-  async fetchGasPricesOnChain(throwIfFailsToFetch = true): Promise<GasPrice> {
-    for (let oracle of Object.values(this.onChainOracles)) {
-      const { name, callData, contract, denominator } = oracle;
-      let { rpc } = oracle;
-      rpc = rpc ? rpc : this.defaultRpc;
-      const body = { jsonrpc: '2.0',
-        id: 1337,
-        method: 'eth_call',
-        params: [{ 'data': callData, 'to': contract }, 'latest']
+      const gasPrices: GasPrice = {
+        instant: parseFloat(gas[instantPropertyName]) / denominator,
+        fast: parseFloat(gas[fastPropertyName]) / denominator,
+        standard: parseFloat(gas[standardPropertyName]) / denominator,
+        low: parseFloat(gas[lowPropertyName]) / denominator,
       };
+      return this.normalize(gasPrices);
+    } else {
+      throw new Error(`Fetch gasPrice from ${name} oracle failed. Trying another one...`);
+    }
+  }
+  async fetchGasPricesOffChain(): Promise<GasPrice> {
+    for (const oracle of Object.values(this.offChainOracles)) {
       try {
-        const response = await fetch(rpc, {
-          headers: {
-            'content-type': 'application/json'
-          },
-          body: JSON.stringify(body),
-          method: 'POST'
-        });
-        if (response.status === 200) {
-          const { result } = await response.json();
-          let fastGasPrice = new BigNumber(result);
-          if (fastGasPrice.isZero()) {
-            throw new Error(`${name} oracle provides corrupted values`);
-          }
-          fastGasPrice = fastGasPrice.div(denominator);
-          const gasPrices: GasPrice = {
-            instant: fastGasPrice.multipliedBy(1.3).toNumber(),
-            fast: fastGasPrice.toNumber(),
-            standard: fastGasPrice.multipliedBy(0.85).toNumber(),
-            low: fastGasPrice.multipliedBy(0.5).toNumber()
-          };
-          this.lastGasPrice = gasPrices;
-          return this.lastGasPrice;
-        } else {
-          throw new Error(`Fetch gasPrice from ${name} oracle failed. Trying another one...`);
-        }
+        return await this.askOracle(oracle);
       } catch (e) {
-        console.error(e.message);
+        console.info(e.message);
+        continue;
       }
     }
-    if (throwIfFailsToFetch) {
-      throw new Error('All oracles are down. Probaly network error.');
-    }
-    return this.lastGasPrice;
+    throw new Error('All oracles are down. Probably a network error.');
   }
 
-  async gasPrices(): Promise<GasPrice> {
-    let gas = this.lastGasPrice;
-    try {
-      gas = await this.fetchGasPricesOffChain();
-      return gas;
-    } catch (e) {
-      console.log('Failed to fetch gas prices from offchain oracles. Trying onchain ones...');
+  async fetchMedianGasPriceOffChain(): Promise<GasPrice> {
+    const promises: Promise<GasPrice>[] = [];
+    for (const oracle of Object.values(this.offChainOracles) as Array<OffChainOracle>) {
+      promises.push(this.askOracle(oracle));
     }
 
-    try {
-      gas = await this.fetchGasPricesOnChain();
-      return gas;
-    } catch (e) {
-      console.log('Failed to fetch gas prices from onchain oracles. Last known gas will be returned');
+    const settledPromises = await Promise.allSettled(promises);
+    const allGasPrices = settledPromises.reduce((acc: GasPrice[], result) => {
+      if (result.status === 'fulfilled') {
+        acc.push(result.value);
+        return acc;
+      }
+      return acc;
+    }, []);
+
+    if (allGasPrices.length === 0) {
+      throw new Error('All oracles are down. Probably a network error.');
+    }
+    return this.median(allGasPrices);
+  }
+
+  median(gasPrices: GasPrice[]): GasPrice {
+    const medianGasPrice: GasPrice = { instant: 0, fast: 0, standard: 0, low: 0 };
+
+    const results: { [key in GasPriceKey]: number[] } = {
+      instant: [],
+      fast: [],
+      standard: [],
+      low: [],
+    };
+
+    for (const gasPrice of gasPrices) {
+      results.instant.push(gasPrice.instant);
+      results.fast.push(gasPrice.fast);
+      results.standard.push(gasPrice.standard);
+      results.low.push(gasPrice.low);
+    }
+
+    for (const type of Object.keys(medianGasPrice) as Array<keyof GasPrice>) {
+      const allPrices = results[type].sort((a, b) => a - b);
+      if (allPrices.length === 1) {
+        medianGasPrice[type] = allPrices[0];
+        continue;
+      } else if (allPrices.length === 0) {
+        continue;
+      }
+      const isEven = allPrices.length % 2 === 0;
+      const middle = Math.floor(allPrices.length / 2);
+      medianGasPrice[type] = isEven ? (allPrices[middle - 1] + allPrices[middle]) / 2.0 : allPrices[middle];
+    }
+    return this.normalize(medianGasPrice);
+  }
+  /**
+   * Normalizes GasPrice values to Gwei. No more than 9 decimals basically
+   * @param GasPrice _gas
+   */
+  normalize(_gas: GasPrice): GasPrice {
+    const format = {
+      decimalSeparator: '.',
+      groupSeparator: '',
+    };
+    const decimals = 9;
+
+    const gas: GasPrice = { ..._gas };
+    for (const type of Object.keys(gas) as Array<keyof GasPrice>) {
+      gas[type] = Number(new BigNumber(gas[type]).toFormat(decimals, format));
     }
 
     return gas;
   }
 
-  addOffChainOracle(oracle: OffChainOracle) {
+  async fetchGasPricesOnChain(): Promise<number> {
+    for (const oracle of Object.values(this.onChainOracles)) {
+      const { name, callData, contract, denominator, rpc } = oracle;
+      const rpcUrl = rpc || this.configuration.defaultRpc;
+      const body = {
+        jsonrpc: '2.0',
+        id: 1337,
+        method: 'eth_call',
+        params: [{ data: callData, to: contract }, 'latest'],
+      };
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const response = await axios.post(rpcUrl!, body, { timeout: this.configuration.timeout });
+        if (response.status === 200) {
+          const { result } = response.data;
+          let fastGasPrice = new BigNumber(result);
+          if (fastGasPrice.isZero()) {
+            throw new Error(`${name} oracle provides corrupted values`);
+          }
+          fastGasPrice = fastGasPrice.div(denominator);
+          return fastGasPrice.toNumber();
+        } else {
+          throw new Error(`Fetch gasPrice from ${name} oracle failed. Trying another one...`);
+        }
+      } catch (e) {
+        console.error(e.message);
+      }
+    }
+    throw new Error('All oracles are down. Probably a network error.');
+  }
+
+  async fetchGasPriceFromRpc(): Promise<number> {
+    const rpcUrl = this.configuration.defaultRpc;
+    const body = {
+      jsonrpc: '2.0',
+      id: 1337,
+      method: 'eth_gasPrice',
+      params: [],
+    };
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const response = await axios.post(rpcUrl!, body, { timeout: this.configuration.timeout });
+      if (response.status === 200) {
+        const { result } = response.data;
+        let fastGasPrice = new BigNumber(result);
+        if (fastGasPrice.isZero()) {
+          throw new Error(`Default RPC provides corrupted values`);
+        }
+        fastGasPrice = fastGasPrice.div(1e9);
+        return fastGasPrice.toNumber();
+      }
+
+      throw new Error(`Fetch gasPrice from default RPC failed..`);
+    } catch (e) {
+      console.error(e.message);
+      throw new Error('Default RPC is down. Probably a network error.');
+    }
+  }
+
+  async gasPrices(fallbackGasPrices?: GasPrice, median = true): Promise<GasPrice> {
+    this.lastGasPrice = this.lastGasPrice || fallbackGasPrices || this.configuration.defaultFallbackGasPrices;
+
+    if (Object.keys(this.offChainOracles).length > 0) {
+      try {
+        this.lastGasPrice = median
+          ? await this.fetchMedianGasPriceOffChain()
+          : await this.fetchGasPricesOffChain();
+        return this.lastGasPrice;
+      } catch (e) {
+        console.log('Failed to fetch gas prices from offchain oracles. Trying onchain ones...');
+      }
+    }
+
+    if (Object.keys(this.onChainOracles).length > 0) {
+      try {
+        const fastGas = await this.fetchGasPricesOnChain();
+        this.lastGasPrice = {
+          instant: fastGas * 1.3,
+          fast: fastGas,
+          standard: fastGas * 0.85,
+          low: fastGas * 0.5,
+        };
+        return this.lastGasPrice;
+      } catch (e) {
+        console.log('Failed to fetch gas prices from onchain oracles. Trying from default RPC...');
+      }
+    }
+
+    try {
+      const fastGas = await this.fetchGasPriceFromRpc();
+      this.lastGasPrice = {
+        instant: fastGas * 1.3,
+        fast: fastGas,
+        standard: fastGas * 0.85,
+        low: fastGas * 0.5,
+      };
+      return this.lastGasPrice;
+    } catch (e) {
+      console.log('Failed to fetch gas prices from default RPC. Last known gas will be returned');
+    }
+    return this.lastGasPrice;
+  }
+
+  addOffChainOracle(oracle: OffChainOracle): void {
     this.offChainOracles[oracle.name] = oracle;
   }
 
-  addOnChainOracle(oracle: OnChainOracle) {
+  addOnChainOracle(oracle: OnChainOracle): void {
     this.onChainOracles[oracle.name] = oracle;
   }
 
-  removeOnChainOracle(name: string) {
+  removeOnChainOracle(name: string): void {
     delete this.onChainOracles[name];
   }
 
-  removeOffChainOracle(name: string) {
+  removeOffChainOracle(name: string): void {
     delete this.offChainOracles[name];
   }
 }

src/types.ts

@@ -6,8 +6,11 @@ export type OffChainOracle = {
   standardPropertyName: string;
   lowPropertyName: string;
   denominator: number;
+  additionalDataProperty: string | null;
 };
 
+export type OffChainOracles = { [key: string]: OffChainOracle };
+
 export type OnChainOracle = {
   name: string;
   rpc?: string;
@@ -16,9 +19,28 @@ export type OnChainOracle = {
   denominator: string;
 };
 
-export type GasPrice = {
-  instant: number;
-  fast: number;
-  standard: number;
-  low: number;
+export type OnChainOracles = { [key: string]: OnChainOracle };
+
+export type AllOracles = {
+  offChainOracles: OffChainOracles;
+  onChainOracles: OnChainOracles;
+};
+
+export type GasPrice = {
+  [key in GasPriceKey]: number;
+};
+
+export type GasPriceKey = 'instant' | 'fast' | 'standard' | 'low';
+
+export type Options = {
+  chainId?: number;
+  defaultRpc?: string;
+  timeout?: number;
+  defaultFallbackGasPrices?: GasPrice;
+};
+
+export type Config = Required<Options>;
+
+export type NetworkConfig = {
+  [key in number]: AllOracles;
 };

tests/index.test.ts

@@ -1,22 +1,47 @@
-import { GasPrice } from '../src/types';
-import mockery from 'mockery';
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-var-requires */
 import chai from 'chai';
-import { onChainOracles } from '../src/config';
+import mockery from 'mockery';
+
+import { ChainId, NETWORKS } from '../src/config';
+import { GasPriceOracle } from '../src/index';
+
+import { GasPrice, OffChainOracle } from '../src/types';
 
-const { GasPriceOracle } = require('../src/index');
 chai.use(require('chai-as-promised'));
 chai.should();
+
 let oracle = new GasPriceOracle();
+let { onChainOracles, offChainOracles } = oracle;
 
 before('before', function () {
-  let fetchMock = () => {
-    throw new Error('Mocked for tests');
+  const axiosMock = {
+    get: () => {
+      throw new Error('axios GET method is mocked for tests');
+    },
+    post: () => {
+      throw new Error('axios POST method is mocked for tests');
+    },
   };
-  mockery.registerMock('node-fetch', fetchMock);
+  mockery.registerMock('axios', axiosMock);
 });
 
 beforeEach('beforeEach', function () {
   oracle = new GasPriceOracle();
+  ({ onChainOracles, offChainOracles } = oracle);
+});
+
+describe('constructor', function () {
+  it('should set default values', async function () {
+    oracle.configuration.defaultRpc.should.be.equal('https://api.mycryptoapi.com/eth');
+    oracle.configuration.timeout.should.be.equal(10000);
+  });
+
+  it('should set passed values', async function () {
+    const newOracle = new GasPriceOracle({ timeout: 1337 });
+    newOracle.configuration.defaultRpc.should.be.equal('https://api.mycryptoapi.com/eth');
+    newOracle.configuration.timeout.should.be.equal(1337);
+  });
 });
 
 describe('fetchGasPricesOffChain', function () {
@@ -28,9 +53,9 @@ describe('fetchGasPricesOffChain', function () {
     gas.standard.should.be.a('number');
     gas.low.should.be.a('number');
 
-    gas.instant.should.be.above(gas.fast);
-    gas.fast.should.be.above(gas.standard);
-    gas.standard.should.be.above(gas.low);
+    gas.instant.should.be.at.least(gas.fast); // greater than or equal to the given number.
+    gas.fast.should.be.at.least(gas.standard);
+    gas.standard.should.be.at.least(gas.low);
     gas.low.should.not.be.equal(0);
   });
 
@@ -38,89 +63,93 @@ describe('fetchGasPricesOffChain', function () {
     mockery.enable({ useCleanCache: true, warnOnUnregistered: false });
     const { GasPriceOracle } = require('../src/index');
     oracle = new GasPriceOracle();
-    await oracle.fetchGasPricesOffChain().should.be.rejectedWith('All oracles are down. Probaly network error.');
-    mockery.disable();
-  });
-
-  it('should not throw if throwIfFailsToFetch is false', async function () {
-    mockery.enable({ useCleanCache: true, warnOnUnregistered: false });
-    const { GasPriceOracle } = require('../src/index');
-    oracle = new GasPriceOracle();
-    await oracle.fetchGasPricesOffChain(false);
+    await oracle
+      .fetchGasPricesOffChain()
+      .should.be.rejectedWith('All oracles are down. Probably a network error.');
     mockery.disable();
   });
 });
 
 describe('fetchGasPricesOnChain', function () {
   it('should work', async function () {
-    const gas: GasPrice = await oracle.fetchGasPricesOnChain();
-
-    gas.instant.should.be.a('number');
-    gas.fast.should.be.a('number');
-    gas.standard.should.be.a('number');
-    gas.low.should.be.a('number');
-
-    gas.instant.should.be.above(gas.fast);
-    gas.fast.should.be.above(gas.standard);
-    gas.standard.should.be.above(gas.low);
-    gas.low.should.not.be.equal(0);
+    const gas: number = await oracle.fetchGasPricesOnChain();
+    gas.should.be.a('number');
+    gas.should.be.above(1);
+    gas.should.not.be.equal(0);
   });
 
   it('should work with custom rpc', async function () {
     const rpc = 'https://ethereum-rpc.trustwalletapp.com';
-    const oracle = new GasPriceOracle(rpc);
-    oracle.defaultRpc.should.be.equal(rpc);
-    const gas: GasPrice = await oracle.fetchGasPricesOnChain();
+    const oracle = new GasPriceOracle({ defaultRpc: rpc });
+    oracle.configuration.defaultRpc.should.be.equal(rpc);
+    const gas: number = await oracle.fetchGasPricesOnChain();
 
-    gas.instant.should.be.a('number');
-    gas.fast.should.be.a('number');
-    gas.standard.should.be.a('number');
-    gas.low.should.be.a('number');
+    gas.should.be.a('number');
 
-    gas.instant.should.be.above(gas.fast);
-    gas.fast.should.be.above(gas.standard);
-    gas.standard.should.be.above(gas.low);
-    gas.low.should.not.be.equal(0);
+    gas.should.be.above(1);
+    gas.should.not.be.equal(0);
   });
 
   it('should remove oracle', async function () {
     await oracle.fetchGasPricesOnChain();
     oracle.removeOnChainOracle('chainlink');
-    await oracle.fetchGasPricesOnChain().should.be.rejectedWith('All oracles are down. Probaly network error.');
+    await oracle
+      .fetchGasPricesOnChain()
+      .should.be.rejectedWith('All oracles are down. Probably a network error.');
   });
 
   it('should add oracle', async function () {
     const { chainlink } = onChainOracles;
     await oracle.fetchGasPricesOnChain();
     oracle.removeOnChainOracle('chainlink');
-    await oracle.fetchGasPricesOnChain().should.be.rejectedWith('All oracles are down. Probaly network error.');
+    await oracle
+      .fetchGasPricesOnChain()
+      .should.be.rejectedWith('All oracles are down. Probably a network error.');
     oracle.addOnChainOracle(chainlink);
-    const gas: GasPrice = await oracle.fetchGasPricesOnChain();
+    const gas: number = await oracle.fetchGasPricesOnChain();
 
-    gas.instant.should.be.a('number');
-    gas.fast.should.be.a('number');
-    gas.standard.should.be.a('number');
-    gas.low.should.be.a('number');
-
-    gas.instant.should.be.above(gas.fast);
-    gas.fast.should.be.above(gas.standard);
-    gas.standard.should.be.above(gas.low);
-    gas.low.should.not.be.equal(0);
+    gas.should.be.a('number');
+    gas.should.not.be.equal(0);
   });
 
   it('should throw if all onchain oracles are down', async function () {
     mockery.enable({ useCleanCache: true, warnOnUnregistered: false });
     const { GasPriceOracle } = require('../src/index');
     oracle = new GasPriceOracle();
-    await oracle.fetchGasPricesOnChain().should.be.rejectedWith('All oracles are down. Probaly network error.');
+    await oracle
+      .fetchGasPricesOnChain()
+      .should.be.rejectedWith('All oracles are down. Probably a network error.');
     mockery.disable();
   });
+});
 
-  it('should not throw if throwIfFailsToFetch is false', async function () {
+describe('fetchGasPriceFromRpc', function () {
+  it('should work', async function () {
+    const gas: number = await oracle.fetchGasPriceFromRpc();
+    gas.should.be.a('number');
+    gas.should.be.above(1);
+    gas.should.not.be.equal(0);
+  });
+
+  it('should work with custom rpc', async function () {
+    const rpc = 'https://ethereum-rpc.trustwalletapp.com';
+    const oracle = new GasPriceOracle({ defaultRpc: rpc });
+    oracle.configuration.defaultRpc.should.be.equal(rpc);
+    const gas: number = await oracle.fetchGasPriceFromRpc();
+
+    gas.should.be.a('number');
+
+    gas.should.be.above(1);
+    gas.should.not.be.equal(0);
+  });
+
+  it('should throw if default rpc is down', async function () {
     mockery.enable({ useCleanCache: true, warnOnUnregistered: false });
     const { GasPriceOracle } = require('../src/index');
     oracle = new GasPriceOracle();
-    await oracle.fetchGasPricesOnChain(false);
+    await oracle
+      .fetchGasPriceFromRpc()
+      .should.be.rejectedWith('Default RPC is down. Probably a network error.');
     mockery.disable();
   });
 });
@@ -134,11 +163,113 @@ describe('gasPrice', function () {
     gas.standard.should.be.a('number');
     gas.low.should.be.a('number');
 
-    gas.instant.should.be.above(gas.fast);
-    gas.fast.should.be.above(gas.standard);
-    gas.standard.should.be.above(gas.low);
+    gas.instant.should.be.at.least(gas.fast);
+    gas.fast.should.be.at.least(gas.standard);
+    gas.standard.should.be.at.least(gas.low);
     gas.low.should.not.be.equal(0);
   });
+  it('should fallback', async function () {
+    mockery.enable({ useCleanCache: true, warnOnUnregistered: false });
+    const { GasPriceOracle } = require('../src/index');
+    oracle = new GasPriceOracle();
+    const gas: GasPrice = await oracle.gasPrices();
+
+    gas.instant.should.be.equal(28.6);
+    gas.fast.should.be.equal(22);
+    gas.standard.should.be.equal(18.7);
+    gas.low.should.be.equal(11);
+    mockery.disable();
+  });
+
+  it('should fallback to set values', async function () {
+    mockery.enable({ useCleanCache: true, warnOnUnregistered: false });
+    const { GasPriceOracle } = require('../src/index');
+    oracle = new GasPriceOracle();
+    const gas: GasPrice = await oracle.gasPrices({ instant: 50, fast: 21, standard: 10, low: 3 });
+
+    gas.instant.should.be.equal(50);
+    gas.fast.should.be.equal(21);
+    gas.standard.should.be.equal(10);
+    gas.low.should.be.equal(3);
+    mockery.disable();
+  });
+});
+
+describe('median', function () {
+  it('should work', async function () {
+    const gas1 = { instant: 100, fast: 100, standard: 100, low: 100 };
+    const gas2 = { instant: 90, fast: 90, standard: 90, low: 90 };
+    const gas3 = { instant: 70, fast: 70, standard: 70, low: 70 };
+    const gas4 = { instant: 110.1, fast: 110.1, standard: 110.1, low: 110.1 };
+    let gas: GasPrice = await oracle.median([gas1, gas2, gas3]);
+    gas.instant.should.be.a('number');
+    gas.fast.should.be.a('number');
+    gas.standard.should.be.a('number');
+    gas.low.should.be.a('number');
+
+    gas.instant.should.be.eq(90);
+    gas.fast.should.be.eq(90);
+    gas.standard.should.be.eq(90);
+    gas.low.should.be.eq(90);
+
+    gas = await oracle.median([gas1, gas2, gas3, gas4]);
+    gas.instant.should.be.a('number');
+    gas.fast.should.be.a('number');
+    gas.standard.should.be.a('number');
+    gas.low.should.be.a('number');
+
+    gas.instant.should.be.eq(95);
+    gas.fast.should.be.eq(95);
+    gas.standard.should.be.eq(95);
+    gas.low.should.be.eq(95);
+  });
+});
+
+describe('fetchMedianGasPriceOffChain', function () {
+  it('should work', async function () {
+    const gas: GasPrice = await oracle.fetchMedianGasPriceOffChain();
+    gas.instant.should.be.a('number');
+    gas.fast.should.be.a('number');
+    gas.standard.should.be.a('number');
+    gas.low.should.be.a('number');
+
+    gas.instant.should.be.at.least(gas.fast); // greater than or equal to the given number.
+    gas.fast.should.be.at.least(gas.standard);
+    gas.standard.should.be.at.least(gas.low);
+    gas.low.should.not.be.equal(0);
+  });
+});
+
+describe('askOracle', function () {
+  const chains = Object.keys(NETWORKS).map(id => Number(id));
+
+  chains.forEach(chainId => {
+    describe(`all ${ChainId[chainId]} oracles should answer`, function () {
+      oracle = new GasPriceOracle({ chainId });
+      ({ offChainOracles } = oracle);
+
+      for (const o of Object.values(offChainOracles) as Array<OffChainOracle>) {
+        it(`check ${o.name}`, async function () {
+          try {
+            const gas: GasPrice = await oracle.askOracle(o);
+
+            gas.instant.should.be.a('number');
+            gas.fast.should.be.a('number');
+            gas.standard.should.be.a('number');
+            gas.low.should.be.a('number');
+
+            gas.instant.should.be.at.least(gas.fast); // greater than or equal to the given number.
+            gas.fast.should.be.at.least(gas.standard);
+            gas.standard.should.be.at.least(gas.low);
+            gas.low.should.not.be.equal(0);
+          } catch (e) {
+            console.error(`Failed to get data from ${o.name} oracle`);
+            throw new Error(e);
+          }
+        });
+      }
+    });
+  });
 });
 
 after('after', function () {

tsconfig.json

@@ -6,13 +6,15 @@
     "lib": [
       "es2017",
       "esnext.asynciterable",
-      "es2019"
-      ] /* Specify library files to be included in the compilation. */,
-    "outDir": "./lib",                        /* Redirect output structure to the directory. */
+      "es2019",
+      "ES2020.Promise"
+    ] /* Specify library files to be included in the compilation. */,
+    "outDir": "./lib" /* Redirect output structure to the directory. */,
     "strict": true /* Enable all strict type-checking options. */,
     "strictPropertyInitialization": false /* Enable strict checking of property initialization in classes. */,
     "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
-    "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    "declaration": true /* Generates corresponding '.d.ts' file. */,
+    "forceConsistentCasingInFileNames": true,
     // "allowJs": true,                       /* Allow javascript files to be compiled. */
     // "checkJs": true,                       /* Report errors in .js files. */
     // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
@@ -60,11 +62,7 @@
     /* Experimental Options */
     "experimentalDecorators": true /* Enables experimental support for ES7 decorators. */,
     "emitDecoratorMetadata": true /* Enables experimental support for emitting type metadata for decorators. */,
-    "plugins": [
-      {
-        "name": "typescript-tslint-plugin"
-      }
-    ]
+    "plugins": []
   },
   "include": ["src"],
   "exclude": ["node_modules", "tests"]

tslint.json

@@ -1,10 +0,0 @@
-{
-  "extends": "tslint-config-standard",
-  "defaultSeverity": "error",
-  "rules": {
-    "semicolon": [true, "always"],
-    "space-before-function-paren": [true, {"anonymous": "always", "named": "never", "asyncArrow": "always"}],
-    "type-literal-delimiter": true
-  }
-}
-