Add gas-price-oracle package

This commit is contained in:
Theo 2023-05-17 11:26:54 +03:00
parent 55fc28dacf
commit db1d4f9b6f
47 changed files with 17467 additions and 14058 deletions

@ -0,0 +1,13 @@
# editorconfig.org
root = true
[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
[*.md]
trim_trailing_whitespace = false

@ -0,0 +1,38 @@
{
"env": {
"node": true,
"browser": true,
"es6": true,
"mocha": true
},
"plugins": ["prettier", "eslint-plugin-import", "eslint-plugin-node", "eslint-plugin-promise", "@typescript-eslint"],
"extends": ["prettier", "eslint:recommended", "plugin:@typescript-eslint/recommended", "plugin:prettier/recommended"],
"globals": {
"Atomics": "readonly",
"SharedArrayBuffer": "readonly"
},
"parserOptions": {
"parser": "@typescript-eslint/parser",
"project": "./tsconfig.json",
"sourceType": "module",
"target": "esnext",
"module": "commonjs"
},
"rules": {
"node/no-callback-literal": 0,
"prettier/prettier": ["error", { "printWidth": 130 }],
"jsx-quotes": ["error", "prefer-single"],
"@typescript-eslint/restrict-template-expressions": ["warn", { "allowNumber": true }],
"@typescript-eslint/explicit-function-return-type": 0,
"@typescript-eslint/array-type": 2,
"@typescript-eslint/camelcase": 0,
"@typescript-eslint/consistent-type-definitions": 0,
"@typescript-eslint/no-empty-function": 2,
"@typescript-eslint/no-empty-interface": 2,
"@typescript-eslint/no-explicit-any": 2,
"@typescript-eslint/no-extra-non-null-assertion": 2,
"@typescript-eslint/require-await": 2,
"@typescript-eslint/no-floating-promises": 0,
"@typescript-eslint/strict-boolean-expressions": 0
}
}

@ -0,0 +1,60 @@
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: 16.15.1
- 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
- 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

91
@tornado/gas-price-oracle/.gitignore vendored Normal file

@ -0,0 +1,91 @@
# Created by .ignore support plugin (hsz.mobi)
### Node template
# Logs
/logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Runtime data
pids
*.pid
*.seed
*.pid.lock
# Directory for instrumented libs generated by jscoverage/JSCover
lib
lib-cov
# Coverage directory used by tools like istanbul
coverage
# nyc test coverage
.nyc_output
# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
.grunt
# Bower dependency directory (https://bower.io/)
bower_components
# node-waf configuration
.lock-wscript
# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release
# Dependency directories
node_modules/
jspm_packages/
# TypeScript v1 declaration files
typings/
# Optional npm cache directory
.npm
# Optional eslint cache
.eslintcache
# Optional REPL history
.node_repl_history
# Output of 'npm pack'
*.tgz
# Yarn Integrity file
.yarn-integrity
# dotenv environment variables file
.env
# parcel-bundler cache (https://parceljs.org/)
.cache
# next.js build output
.next
# nuxt.js build output
.nuxt
# Nuxt generate
dist
# vuepress build output
.vuepress/dist
# Serverless directories
.serverless
# IDE / Editor
.idea
# Service worker
sw.*
# macOS
.DS_Store
# Vim swap files
*.swp

@ -0,0 +1 @@
16.15.1

@ -0,0 +1 @@
lib

@ -0,0 +1,8 @@
{
"semi": false,
"trailingComma": "all",
"singleQuote": true,
"jsxSingleQuote": true,
"printWidth": 130,
"tabWidth": 2
}

@ -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.

@ -0,0 +1,311 @@
# 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)
This is a library with 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
Current onchain list:
- [chainlink](https://etherscan.io/address/0x169e633a2d1e6c10dd91238ba11c4a708dfef37c#readContract)
### Binance Smart Chain
Current offchain list:
- https://ztake.org/
### Gnosis 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/
### Avalanche C Network
Current offchain list:
- https://gavax.blockscan.com/gasapi.ashx?apikey=key&method=gasoracle
## Installation
`npm i gas-price-oracle`
or
`yarn add gas-price-oracle`
## Import
```js
const { GasPriceOracle } = require('gas-price-oracle')
or
import { GasPriceOracle } from 'gas-price-oracle'
```
## Usage
### Configuration
```typescript
type GasPrice = Record<'instant' | 'fast' | 'standard' | 'low', number>
type EstimatedGasPrice = {
maxFeePerGas: number
baseFee: number | undefined
maxPriorityFeePerGas: number
}
type FallbackGasPrices = {
gasPrices?: GasPrice
estimated?: EstimatedGasPrice
}
type GasOracleOptions = {
chainId?: number
timeout?: number
defaultRpc?: string
blocksCount?: number
percentile?: number
blockTime?: number // seconds
shouldCache?: boolean
fallbackGasPrices?: FallbackGasPrices
}
const options: GasOracleOptions = {
chainId: 1,
percentile: 5, // Which percentile of effective priority fees to include
blocksCount: 10, // How many blocks to consider for priority fee estimation
defaultRpc: 'https://api.mycryptoapi.com/eth',
blockTime: 10, // seconds
shouldCache: false,
timeout: 10000, // specifies the number of milliseconds before the request times out.
minPriority: 0, // specifies the min maxPriorityFeePerGas.
fallbackGasPrices: {
gasPrices: {
instant: 28,
fast: 22,
standard: 17,
low: 11,
},
estimated: {
maxFeePerGas: 20,
maxPriorityFeePerGas: 3,
},
},
}
```
### The Oracle can cache rpc calls
For caching needs to provide to GasOracleOptions
`shouldCache: true`
`blockTime: <Chain block time duration>`
### EIP-1559 (estimated) gasPrice only
```typescript
const oracle = new GasPriceOracle({ chainId: 1 })
type EstimatedGasPrice = {
maxFeePerGas: number
baseFee: number | undefined
maxPriorityFeePerGas: number
}
fallbackGasPrices: EstimatedGasPrice = {
maxFeePerGas: 20,
maxPriorityFeePerGas: 3,
}
oracle.eip1559.estimateFees(fallbackGasPrices).then((gasPrices: EstimatedGasPrice) => {
console.log(gasPrices) // { baseFee: 14, maxFeePerGas: 17, maxPriorityFeePerGas: 3 }
})
```
### Legacy gasPrice only
```typescript
const oracle = new GasPriceOracle({ chainId: 1 })
type GasPrice = Record<'instant' | 'fast' | 'standard' | 'low', number>
fallbackGasPrices: GasPrice = {
instant: 28,
fast: 22,
standard: 17,
low: 11,
}
oracle.legacy.gasPrices(fallbackGasPrices).then((gasPrices: GasPrice) => {
console.log(gasPrices) // { instant: 21.5, fast: 19, standard: 17, low: 15 }
})
```
The `oracle.legacy.gasPrices` method also accepts `shouldGetMedian` 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.
### Estimated gasPrices (EIP-1559) and Legacy gasPrice
```ts
const oracle = new GasPriceOracle(options)
type GasPriceWithEstimate = {
gasPrices: GasPrice
estimate: EstimatedGasPrice
}
type GasPricesWithEstimateInput = {
shouldGetMedian?: boolean
fallbackGasPrices?: FallbackGasPrices
}
// optional fallbackGasPrices
const fallbackGasPrices: FallbackGasPrices = {
gasPrices: {
instant: 28,
fast: 22,
standard: 17,
low: 11,
},
estimated: {
maxFeePerGas: 20,
maxPriorityFeePerGas: 3,
},
}
oracle.gasPricesWithEstimate({ fallbackGasPrices, shouldGetMedian: true }).then((gasPrices: GasPriceWithEstimate) => {
console.log(gasPrices) // {
// estimated: { baseFee: 14, maxFeePerGas: 17, maxPriorityFeePerGas: 3 },
// gasPrices: { instant: 21.5, fast: 19, standard: 17, low: 15 }
// }}
})
```
### Estimated gasPrices (EIP-1559) or Legacy gasPrice
```typescript
const oracle = new GasPriceOracle(options)
type GetGasPriceInput = {
isLegacy?: boolean
shouldGetMedian?: boolean
fallbackGasPrices?: GasPrice
}
// optional fallbackGasPrices
const fallbackGasPrices: FallbackGasPrices = {
gasPrices: {
instant: 28,
fast: 22,
standard: 17,
low: 11,
},
estimated: {
maxFeePerGas: 20,
maxPriorityFeePerGas: 3,
},
}
oracle.gasPrices({ fallbackGasPrices, shouldGetMedian: true }).then((gasPrices: GasPrice | EstimatedGasPrice) => {
console.log(gasPrices) // {
// baseFee: 14, maxFeePerGas: 17, maxPriorityFeePerGas: 3 ||
// instant: 21.5, fast: 19, standard: 17, low: 15
// }}
})
```
The `gasPrices` method also accepts `isLegacy` argument (`false`) by default. If `isLegacy: true` - `legacy gasPrice` will be provided. If the `estimate Gas` crashes, `legacy gas Price` will be provided.
### Get transaction gasPrice params
```typescript
const oracle = new GasPriceOracle(options)
type GetTxGasParamsInput = {
bumpPercent?: number
legacySpeed?: GasPriceKey
isLegacy?: boolean
shouldGetMedian?: boolean
fallbackGasPrices?: FallbackGasPrices
}
type GetTxGasParamsRes =
| {
gasPrice: number
}
| {
maxFeePerGas: number
maxPriorityFeePerGas: number
}
const gasParams: GetTxGasParamsRes = await oracle.getTxGasParams({ legacySpeed: 'fast', bumpPercent: 30 })
console.log(gasParams) // { maxFeePerGas: 17, maxPriorityFeePerGas: 3 } || { gasPrice: 19 }
web3.eth.sendTransaction({
from: '0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8',
to: '0xac03bb73b6a9e108530aff4df5077c2b3d481e5a',
nonce: '0',
gasLimit: '21000',
value: '10000000000',
...gasParams,
})
```
`bumpPercent` argument (`0` by default) - response data will increase by `bumpPercent`%.
`legacySpeed` argument (`fast` by default) - select the speed of legacy gasPrice.
### Offchain oracles only
```typescript
const oracle = new GasPriceOracle({ chainId: 1 })
// shouldGetMedian: boolean | undefined
oracle.legacy.fetchGasPricesOffChain((shouldGetMedian = true)).then((gasPrices: GasPrice) => {
console.log(gasPrices) // { instant: 50, fast: 21, standard: 10, low: 3 }
})
```
### Offchain oracles only (get median price)
```typescript
const oracle = new GasPriceOracle({ chainId: 1 })
oracle.legacy.fetchMedianGasPriceOffChain().then((gasPrices: GasPrice) => {
console.log(gasPrices) // { instant: 50, fast: 21, standard: 10, low: 3 }
})
```
This command provides the median gas price of all configured oracles.
### Custom RPC URL for onchain oracles
```typescript
const defaultRpc = 'https://mainnet.infura.io/v3/<API_KEY>'
const oracle = new GasPriceOracle({ defaultRpc, chainId: 1 })
oracle.legacy.fetchGasPricesOnChain().then((gasPrices: number) => {
console.log(gasPrices) // 21
})
```
To get gasPrices from a chain outside of the application's chain list (Binance, Gnosis, Polygon, Avalanche), you should enter the rpcUrl into initial GasPriceOracle options\_
```typescript
const defaultRpc = 'https://rpc.goerli.mudit.blog/' // goerli public rpcUrl
const oracle = new GasPriceOracle({ defaultRpc, chainId: 5 })
oracle.gasPrices()
```

@ -0,0 +1,66 @@
{
"name": "@tornado/gas-price-oracle",
"version": "0.5.2-p1",
"description": "Gas Price Oracle library for Ethereum dApps.",
"homepage": "https://git.tornado.ws/tornado-packages/gas-price-oracle",
"main": "./lib/index.js",
"module": "./lib/esm/index.js",
"types": "./lib/index.d.ts",
"repository": {
"type": "git",
"url": "https://git.tornado.ws/tornado-packages/archive-monorepo"
},
"scripts": {
"test": "ts-mocha --timeout 30000 --paths 'src/tests/*.test.ts'",
"build": "tsc && tsc-alias",
"build:esm": "tsc -p tsconfig.esm.json && tsc-alias -p tsconfig.esm.json",
"eslint": "eslint 'src/*.ts'",
"prettier:check": "prettier --check . --config .prettierrc",
"prettier:fix": "prettier --write . --config .prettierrc",
"lint": "yarn eslint && yarn prettier:check",
"prepare": "yarn build && yarn build:esm",
"prepublishOnly": "yarn test && yarn lint"
},
"author": "Alexey Pertsev <alexey@peppersec.com> (https://peppersec.com)",
"keywords": [
"Gas",
"Gas price",
"Ethereum",
"Oracle",
"EIP-1559",
"London Fork"
],
"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-import": "^2.26.0",
"eslint-plugin-node": "^11.1.0",
"eslint-plugin-prettier": "^3.1.4",
"eslint-plugin-promise": "^6.0.0",
"mocha": "^7.2.0",
"mockery": "^2.1.0",
"prettier": "^2.1.2",
"ts-mocha": "^10.0.0",
"ts-node": "^8.10.1",
"tsc-alias": "^1.6.11",
"typescript": "^4.7.4"
},
"dependencies": {
"axios": "^0.21.2",
"bignumber.js": "^9.0.0",
"node-cache": "^5.1.2"
},
"files": [
"lib/**/*"
]
}

@ -0,0 +1,10 @@
import { OffChainOracles, OnChainOracles } from '@/services'
export const offChainOracles: OffChainOracles = {}
export const onChainOracles: OnChainOracles = {}
export default {
offChainOracles,
onChainOracles,
}

@ -0,0 +1,23 @@
import { OffChainOracle, OffChainOracles, OnChainOracles } from '@/services'
const avalancheGasStation: OffChainOracle = {
name: 'avalancheGasStation',
url: 'https://gavax.blockscan.com/gasapi.ashx?apikey=key&method=gasoracle',
instantPropertyName: 'FastGasPrice',
fastPropertyName: 'FastGasPrice',
standardPropertyName: 'ProposeGasPrice',
lowPropertyName: 'SafeGasPrice',
denominator: 1,
additionalDataProperty: 'result',
}
export const offChainOracles: OffChainOracles = {
avalancheGasStation,
}
export const onChainOracles: OnChainOracles = {}
export default {
offChainOracles,
onChainOracles,
}

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

@ -0,0 +1,78 @@
import bscOracles from './bsc'
import xdaiOracles from './xdai'
import avalancheOracles from './avax'
import mainnetOracles from './mainnet'
import polygonOracles from './polygon'
import optimismOracles from './optimism'
import arbitrumOracles from './arbitrum'
import { NetworksConfig } from '@/types'
export enum ChainId {
MAINNET = 1,
BSC = 56,
XDAI = 100,
POLYGON = 137,
OPTIMISM = 10,
ARBITRUM = 42161,
AVAX = 43114,
}
export const NETWORKS: Record<number, NetworksConfig> = {
[ChainId.MAINNET]: {
oracles: mainnetOracles,
rpcUrl: 'https://api.mycryptoapi.com/eth',
defaultGasPrice: 22,
maxGasPrice: 1500,
blocksCount: 10,
percentile: 5,
},
[ChainId.BSC]: {
oracles: bscOracles,
rpcUrl: 'https://bsc-dataseed1.ninicoin.io',
defaultGasPrice: 5,
maxGasPrice: 200,
blocksCount: 10,
percentile: 5,
},
[ChainId.XDAI]: {
oracles: xdaiOracles,
rpcUrl: 'https://rpc.gnosischain.com',
defaultGasPrice: 5,
maxGasPrice: 200,
blocksCount: 200,
percentile: 5,
},
[ChainId.POLYGON]: {
oracles: polygonOracles,
rpcUrl: 'https://rpc-mainnet.maticvigil.com',
defaultGasPrice: 75,
maxGasPrice: 1000,
blocksCount: 10,
percentile: 5,
},
[ChainId.OPTIMISM]: {
oracles: optimismOracles,
rpcUrl: 'https://mainnet.optimism.io',
defaultGasPrice: 0.001,
maxGasPrice: 5,
blocksCount: 10,
percentile: 5,
},
[ChainId.ARBITRUM]: {
oracles: arbitrumOracles,
rpcUrl: 'https://arb1.arbitrum.io/rpc',
defaultGasPrice: 3,
maxGasPrice: 15,
blocksCount: 10,
percentile: 5,
},
[ChainId.AVAX]: {
oracles: avalancheOracles,
rpcUrl: 'https://api.avax.network/ext/bc/C/rpc',
defaultGasPrice: 50,
maxGasPrice: 1000,
blocksCount: 10,
percentile: 5,
},
}

@ -0,0 +1,44 @@
import { OffChainOracle, OffChainOracles, OnChainOracle, OnChainOracles } from '@/services'
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: 1e9,
additionalDataProperty: 'data',
}
const chainlink: OnChainOracle = {
name: 'chainlink',
callData: '0x50d25bcd',
contract: '0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C',
denominator: '1000000000',
}
export const offChainOracles: OffChainOracles = {
ethgasstation,
etherchain,
}
export const onChainOracles: OnChainOracles = {
chainlink,
}
export default {
offChainOracles,
onChainOracles,
}

@ -0,0 +1,18 @@
import { OffChainOracles, OnChainOracle, OnChainOracles } from '@/services'
export const offChainOracles: OffChainOracles = {}
const optimism: OnChainOracle = {
name: 'optimism',
callData: '0xfe173b97',
denominator: '1000000000',
contract: '0x420000000000000000000000000000000000000F',
}
export const onChainOracles: OnChainOracles = {
optimism,
}
export default {
offChainOracles,
onChainOracles,
}

@ -0,0 +1,23 @@
import { OffChainOracle, OffChainOracles, OnChainOracles } from '@/services'
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,
}

@ -0,0 +1,23 @@
import { OffChainOracle, OffChainOracles, OnChainOracles } from '@/services'
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,
}

@ -0,0 +1,27 @@
import BigNumber from 'bignumber.js'
const GWEI = 1e9
const DEFAULT_TIMEOUT = 10000
const ROUND_UP = 1
const ROUND_DOWN = 2
const GWEI_PRECISION = 9
const INT_PRECISION = 0
const SUCCESS_STATUS = 200
const BG_ZERO = new BigNumber(0)
const PERCENT_MULTIPLIER = 100
const DEFAULT_BLOCK_DURATION = 10
export {
GWEI,
DEFAULT_TIMEOUT,
ROUND_UP,
ROUND_DOWN,
GWEI_PRECISION,
INT_PRECISION,
SUCCESS_STATUS,
BG_ZERO,
PERCENT_MULTIPLIER,
DEFAULT_BLOCK_DURATION,
}

@ -0,0 +1 @@
export * from '@/services/gas-price-oracle'

@ -0,0 +1,20 @@
import NodeCache, { Options } from 'node-cache'
export class NodeJSCache<T> {
private nodeCache: NodeCache
constructor(params: Options) {
this.nodeCache = new NodeCache(params)
}
async get(key: string): Promise<T | undefined> {
return await this.nodeCache.get<T>(key)
}
async set(key: string, value: T): Promise<boolean> {
return await this.nodeCache.set(key, value)
}
async has(key: string): Promise<boolean> {
return await this.nodeCache.has(key)
}
}

@ -0,0 +1 @@
export * from './cacheNode'

@ -0,0 +1,26 @@
// How many blocks to consider for priority fee estimation
import BigNumber from 'bignumber.js'
import { EstimatedGasPrice } from './types'
const FEE_HISTORY_BLOCKS = 10
// Which percentile of effective priority fees to include
const FEE_HISTORY_PERCENTILE = 5
const DEFAULT_BASE_FEE = 20
const DEFAULT_PRIORITY_FEE = 3
const PRIORITY_FEE_INCREASE_BOUNDARY = 200 // %
const FALLBACK_ESTIMATE: EstimatedGasPrice = {
baseFee: DEFAULT_BASE_FEE,
maxPriorityFeePerGas: DEFAULT_PRIORITY_FEE,
maxFeePerGas: new BigNumber(DEFAULT_PRIORITY_FEE).plus(DEFAULT_BASE_FEE).toNumber(),
}
export {
DEFAULT_BASE_FEE,
FALLBACK_ESTIMATE,
FEE_HISTORY_BLOCKS,
DEFAULT_PRIORITY_FEE,
FEE_HISTORY_PERCENTILE,
PRIORITY_FEE_INCREASE_BOUNDARY,
}

@ -0,0 +1,159 @@
import BigNumber from 'bignumber.js'
import { FeeHistory, Block } from '@/types'
import { Config, EstimateOracle, EstimatedGasPrice, CalculateFeesParams, GasEstimationOptionsPayload } from './types'
import { ChainId, NETWORKS } from '@/config'
import { RpcFetcher, NodeJSCache } from '@/services'
import { findMax, fromNumberToHex, fromWeiToGwei, getMedian } from '@/utils'
import { BG_ZERO, DEFAULT_BLOCK_DURATION, PERCENT_MULTIPLIER } from '@/constants'
import { DEFAULT_PRIORITY_FEE, PRIORITY_FEE_INCREASE_BOUNDARY, FEE_HISTORY_BLOCKS, FEE_HISTORY_PERCENTILE } from './constants'
// !!! MAKE SENSE ALL CALCULATIONS IN GWEI !!!
export class Eip1559GasPriceOracle implements EstimateOracle {
public configuration: Config = {
shouldCache: false,
chainId: ChainId.MAINNET,
fallbackGasPrices: undefined,
minPriority: DEFAULT_PRIORITY_FEE,
blockTime: DEFAULT_BLOCK_DURATION,
blocksCount: NETWORKS[ChainId.MAINNET].blocksCount,
percentile: NETWORKS[ChainId.MAINNET].percentile,
}
private fetcher: RpcFetcher
private cache: NodeJSCache<EstimatedGasPrice>
private FEES_KEY = (chainId: ChainId) => `estimate-fee-${chainId}`
constructor({ fetcher, ...options }: GasEstimationOptionsPayload) {
this.fetcher = fetcher
const chainId = options?.chainId || this.configuration.chainId
this.configuration.blocksCount = NETWORKS[chainId]?.blocksCount || FEE_HISTORY_BLOCKS
this.configuration.percentile = NETWORKS[chainId]?.percentile || FEE_HISTORY_PERCENTILE
if (options) {
this.configuration = { ...this.configuration, ...options }
}
this.cache = new NodeJSCache({ stdTTL: this.configuration.blockTime, useClones: false })
}
public async estimateFees(fallbackGasPrices?: EstimatedGasPrice): Promise<EstimatedGasPrice> {
try {
const cacheKey = this.FEES_KEY(this.configuration.chainId)
const cachedFees = await this.cache.get(cacheKey)
if (cachedFees) {
return cachedFees
}
const { data: latestBlock } = await this.fetcher.makeRpcCall<{ result: Block }>({
method: 'eth_getBlockByNumber',
params: ['latest', false],
})
if (!latestBlock.result.baseFeePerGas) {
throw new Error('An error occurred while fetching current base fee, falling back')
}
const baseFee = fromWeiToGwei(latestBlock.result.baseFeePerGas)
const blockCount = fromNumberToHex(this.configuration.blocksCount)
const rewardPercentiles: number[] = [this.configuration.percentile]
const { data } = await this.fetcher.makeRpcCall<{ result: FeeHistory }>({
method: 'eth_feeHistory',
params: [blockCount, 'latest', rewardPercentiles],
})
const fees = await this.calculateFees({ baseFee, feeHistory: data.result })
if (this.configuration.shouldCache) {
await this.cache.set(cacheKey, fees)
}
return fees
} catch (err) {
if (fallbackGasPrices) {
return fallbackGasPrices
}
if (this.configuration.fallbackGasPrices) {
return this.configuration.fallbackGasPrices
}
throw err
}
}
private calculatePriorityFeeEstimate(feeHistory?: FeeHistory) {
if (!feeHistory) {
return null
}
const rewards = feeHistory.reward
?.map((r) => fromWeiToGwei(r[0]))
.filter((r) => r.isGreaterThan(0))
.sort()
if (!rewards) {
return null
}
// Calculate percentage increases from between ordered list of fees
const percentageIncreases = rewards.reduce<BigNumber[]>((acc, curr, i, arr) => {
if (i !== arr.length - 1) {
const next = arr[i + 1]
const percentageIncrease = next.minus(curr).dividedBy(curr).multipliedBy(PERCENT_MULTIPLIER)
acc.push(percentageIncrease)
}
return acc
}, [])
const { highest, index } = findMax(percentageIncreases)
// If we have big increased in value, we could be considering "outliers" in our estimate
// Skip the low elements and take a new median
const values =
highest.isGreaterThanOrEqualTo(PRIORITY_FEE_INCREASE_BOUNDARY) && index >= getMedian(rewards)
? rewards.slice(index)
: rewards
return values[getMedian(values)]
}
private async getPriorityFromChain(feeHistory?: FeeHistory) {
try {
const { data } = await this.fetcher.makeRpcCall<{ result: string }>({
method: 'eth_maxPriorityFeePerGas',
params: [],
})
return fromWeiToGwei(data.result)
} catch (err) {
return this.calculatePriorityFeeEstimate(feeHistory)
}
}
private async calculateFees({ baseFee, feeHistory }: CalculateFeesParams): Promise<EstimatedGasPrice> {
const estimatedPriorityFee = await this.getPriorityFromChain(feeHistory)
const { highest: maxPriorityFeePerGas } = findMax([
estimatedPriorityFee ?? BG_ZERO,
new BigNumber(this.configuration.minPriority),
])
const maxFeePerGas = baseFee.plus(maxPriorityFeePerGas)
if (this.checkIsGreaterThanMax(maxFeePerGas) || this.checkIsGreaterThanMax(maxPriorityFeePerGas)) {
throw new Error('Estimated gas fee was much higher than expected, erroring')
}
return {
baseFee: baseFee.toNumber(),
maxFeePerGas: maxFeePerGas.toNumber(),
maxPriorityFeePerGas: maxPriorityFeePerGas.toNumber(),
}
}
private checkIsGreaterThanMax(value: BigNumber): boolean {
return value.isGreaterThanOrEqualTo(NETWORKS[this.configuration.chainId]?.maxGasPrice) || false
}
}

@ -0,0 +1,2 @@
export * from './eip1559'
export * from './types'

@ -0,0 +1,39 @@
import BigNumber from 'bignumber.js'
import { FeeHistory } from '@/types'
import { RpcFetcher } from '@/services'
export type EstimatedGasPrice = {
maxFeePerGas: number
baseFee: number | undefined
maxPriorityFeePerGas: number
}
export type EstimateFeesParams = {
blocksCount: number
percentile: number
}
export type CalculateFeesParams = {
baseFee: BigNumber
feeHistory?: FeeHistory
}
export type Options = {
chainId?: number
blocksCount?: number
percentile?: number
blockTime?: number
shouldCache?: boolean
fallbackGasPrices: EstimatedGasPrice | undefined
}
export type GasEstimationOptionsPayload = Options & {
fetcher: RpcFetcher
}
export type Config = Required<Options> & { fallbackGasPrices?: EstimatedGasPrice; minPriority: number }
export abstract class EstimateOracle {
public configuration: Config
public abstract estimateFees(fallbackGasPrices?: EstimatedGasPrice): Promise<EstimatedGasPrice>
}

@ -0,0 +1,96 @@
import {
GasOracleOptions,
GasPricesWithEstimateInput,
GasPriceWithEstimate,
GetGasPriceInput,
GetTxGasParamsInput,
GetTxGasParamsRes,
OracleProvider,
} from './types'
import { ChainId, NETWORKS } from '@/config'
import { DEFAULT_TIMEOUT } from '@/constants'
import { bumpOnPercent, fromGweiToWeiHex } from '@/utils'
import {
RpcFetcher,
GasPrice,
LegacyOracle,
EstimateOracle,
EstimatedGasPrice,
LegacyGasPriceOracle,
Eip1559GasPriceOracle,
} from '@/services'
export class GasPriceOracle implements OracleProvider {
public eip1559: EstimateOracle
public legacy: LegacyOracle
public fetcher: RpcFetcher
private chainId: ChainId
public constructor(options?: GasOracleOptions) {
const timeout = options?.timeout ?? DEFAULT_TIMEOUT
this.chainId = options?.chainId || ChainId.MAINNET
const defaultRpc = options?.defaultRpc || NETWORKS[this.chainId].rpcUrl
this.fetcher = new RpcFetcher(defaultRpc, timeout)
const { gasPrices, estimated } = options?.fallbackGasPrices || {}
const payload = { ...options, fetcher: this.fetcher }
this.legacy = new LegacyGasPriceOracle({
...payload,
fallbackGasPrices: gasPrices,
})
this.eip1559 = new Eip1559GasPriceOracle({
...payload,
fallbackGasPrices: estimated,
})
}
public async gasPrices(payload: GetGasPriceInput = {}): Promise<GasPrice | EstimatedGasPrice> {
const { fallbackGasPrices, shouldGetMedian, isLegacy = false } = payload
if (isLegacy) {
return await this.legacy.gasPrices(fallbackGasPrices?.gasPrices, shouldGetMedian)
}
try {
return await this.eip1559.estimateFees(fallbackGasPrices?.estimated)
} catch {
return await this.legacy.gasPrices(fallbackGasPrices?.gasPrices, shouldGetMedian)
}
}
public async getTxGasParams(payload: GetTxGasParamsInput = {}): Promise<GetTxGasParamsRes> {
const { fallbackGasPrices, shouldGetMedian, isLegacy = false, bumpPercent = 0, legacySpeed = 'fast' } = payload
if (isLegacy) {
const legacyGasPrice = await this.legacy.gasPrices(fallbackGasPrices?.gasPrices, shouldGetMedian)
return { gasPrice: fromGweiToWeiHex(bumpOnPercent(legacyGasPrice[legacySpeed], bumpPercent)) }
}
try {
const eipParams = await this.eip1559.estimateFees(fallbackGasPrices?.estimated)
return {
maxFeePerGas: fromGweiToWeiHex(bumpOnPercent(eipParams.maxFeePerGas, bumpPercent)),
maxPriorityFeePerGas: fromGweiToWeiHex(bumpOnPercent(eipParams.maxPriorityFeePerGas, bumpPercent)),
}
} catch {
const legacyGasPrice = await this.legacy.gasPrices(fallbackGasPrices?.gasPrices, shouldGetMedian)
return { gasPrice: fromGweiToWeiHex(bumpOnPercent(legacyGasPrice[legacySpeed], bumpPercent)) }
}
}
public async gasPricesWithEstimate(payload: GasPricesWithEstimateInput = {}): Promise<GasPriceWithEstimate> {
const { fallbackGasPrices, shouldGetMedian } = payload
const estimate = await this.eip1559.estimateFees(fallbackGasPrices?.estimated)
const gasPrices = await this.legacy.gasPrices(fallbackGasPrices?.gasPrices, shouldGetMedian)
return {
estimate,
gasPrices,
}
}
}

@ -0,0 +1,2 @@
export * from './gas-price-oracle'
export * from './types'

@ -0,0 +1,57 @@
import { RpcFetcher, GasPrice, LegacyOracle, EstimatedGasPrice, EstimateOracle, GasPriceKey } from '@/services'
export type GetTxGasParamsInput = GetGasPriceInput & {
bumpPercent?: number
legacySpeed?: GasPriceKey
}
export type GetTxGasParamsRes =
| {
gasPrice: string
}
| {
maxFeePerGas: string
maxPriorityFeePerGas: string
}
export type GetGasPriceInput = {
isLegacy?: boolean
shouldGetMedian?: boolean
fallbackGasPrices?: FallbackGasPrices
}
export type FallbackGasPrices = {
gasPrices?: GasPrice
estimated?: EstimatedGasPrice
}
export type GasPricesWithEstimateInput = {
shouldGetMedian?: boolean
fallbackGasPrices?: FallbackGasPrices
}
export type GasOracleOptions = {
chainId?: number
timeout?: number
defaultRpc?: string
blocksCount?: number
percentile?: number
blockTime?: number
shouldCache?: boolean
minPriority?: number
fallbackGasPrices?: FallbackGasPrices
}
export type GasPriceWithEstimate = {
gasPrices: GasPrice
estimate: EstimatedGasPrice
}
export interface OracleProvider {
eip1559: EstimateOracle
legacy: LegacyOracle
fetcher: RpcFetcher
gasPrices: (payload: GetGasPriceInput) => Promise<GasPrice | EstimatedGasPrice>
gasPricesWithEstimate: (payload: GasPricesWithEstimateInput) => Promise<GasPriceWithEstimate>
getTxGasParams: (payload: GetTxGasParamsInput) => Promise<GetTxGasParamsRes>
}

@ -0,0 +1,7 @@
export * from './gas-price-oracle'
export * from './gas-estimation'
export * from './legacy-gas-price'
export * from './cacher'
export * from './rpcFetcher'

@ -0,0 +1,10 @@
const DEFAULT_GAS_PRICE = { instant: 0, fast: 0, standard: 0, low: 0 }
const MULTIPLIERS = {
instant: 1.3,
fast: 1.2,
standard: 1.1,
low: 1,
}
export { MULTIPLIERS, DEFAULT_GAS_PRICE }

@ -0,0 +1,2 @@
export * from './legacy'
export * from './types'

@ -0,0 +1,317 @@
import axios from 'axios'
import BigNumber from 'bignumber.js'
import {
GasPrice,
GasPriceKey,
LegacyOracle,
OnChainOracle,
OffChainOracle,
LegacyOptions,
OnChainOracles,
OffChainOracles,
LegacyOptionsPayload,
GetGasPriceFromRespInput,
} from './types'
import { ChainId, NETWORKS } from '@/config'
import { RpcFetcher, NodeJSCache } from '@/services'
import { GWEI, DEFAULT_TIMEOUT, GWEI_PRECISION, DEFAULT_BLOCK_DURATION } from '@/constants'
import { MULTIPLIERS, DEFAULT_GAS_PRICE } from './constants'
export class LegacyGasPriceOracle implements LegacyOracle {
static getMedianGasPrice(gasPrices: GasPrice[]): GasPrice {
const medianGasPrice: GasPrice = DEFAULT_GAS_PRICE
const results: Record<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 (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 LegacyGasPriceOracle.normalize(medianGasPrice)
}
static getMultipliedPrices(gasPrice: number): GasPrice {
return {
instant: gasPrice * MULTIPLIERS.instant,
fast: gasPrice * MULTIPLIERS.fast,
standard: gasPrice * MULTIPLIERS.standard,
low: gasPrice * MULTIPLIERS.low,
}
}
static normalize(_gas: GasPrice): GasPrice {
const format = {
groupSeparator: '',
decimalSeparator: '.',
}
const gas: GasPrice = { ..._gas }
for (const type of Object.keys(gas) as (keyof GasPrice)[]) {
gas[type] = Number(new BigNumber(gas[type]).toFormat(GWEI_PRECISION, format))
}
return gas
}
static getCategorize(gasPrice: number): GasPrice {
return LegacyGasPriceOracle.normalize(LegacyGasPriceOracle.getMultipliedPrices(gasPrice))
}
static getGasPriceFromResponse(payload: GetGasPriceFromRespInput): number {
const { response, fetcherName, denominator = GWEI } = payload
let fastGasPrice = new BigNumber(response)
if (fastGasPrice.isZero()) {
throw new Error(`${fetcherName} provides corrupted values`)
}
fastGasPrice = fastGasPrice.div(denominator)
return fastGasPrice.toNumber()
}
public lastGasPrice: GasPrice
public onChainOracles: OnChainOracles = {}
public offChainOracles: OffChainOracles = {}
public configuration: Required<LegacyOptions> = {
shouldCache: false,
chainId: ChainId.MAINNET,
timeout: DEFAULT_TIMEOUT,
blockTime: DEFAULT_BLOCK_DURATION,
defaultRpc: NETWORKS[ChainId.MAINNET].rpcUrl,
fallbackGasPrices: LegacyGasPriceOracle.getMultipliedPrices(NETWORKS[ChainId.MAINNET].defaultGasPrice),
}
private readonly fetcher: RpcFetcher
private cache: NodeJSCache<GasPrice>
private LEGACY_KEY = (chainId: ChainId) => `legacy-fee-${chainId}`
constructor({ fetcher, ...options }: LegacyOptionsPayload) {
this.fetcher = fetcher
if (options) {
this.configuration = { ...this.configuration, ...options }
}
const { defaultGasPrice } = NETWORKS[ChainId.MAINNET]
const fallbackGasPrices = this.configuration.fallbackGasPrices || LegacyGasPriceOracle.getMultipliedPrices(defaultGasPrice)
this.configuration.fallbackGasPrices = LegacyGasPriceOracle.normalize(fallbackGasPrices)
const network = NETWORKS[this.configuration.chainId]?.oracles
if (network) {
this.offChainOracles = { ...network.offChainOracles }
this.onChainOracles = { ...network.onChainOracles }
}
this.cache = new NodeJSCache({ stdTTL: this.configuration.blockTime, useClones: false })
}
public addOffChainOracle(oracle: OffChainOracle): void {
this.offChainOracles[oracle.name] = oracle
}
public addOnChainOracle(oracle: OnChainOracle): void {
this.onChainOracles[oracle.name] = oracle
}
public removeOnChainOracle(name: string): void {
delete this.onChainOracles[name]
}
public removeOffChainOracle(name: string): void {
delete this.offChainOracles[name]
}
public async fetchGasPricesOnChain(): Promise<number> {
for (const oracle of Object.values(this.onChainOracles)) {
const { name, callData, contract, denominator, rpc } = oracle
try {
const response = await this.fetcher.makeRpcCall<{ result: string | number }>({
rpc,
method: 'eth_call',
params: [{ data: callData, to: contract }, 'latest'],
})
if (response.status === 200) {
return LegacyGasPriceOracle.getGasPriceFromResponse({
denominator,
fetcherName: `${name} oracle`,
response: response.data.result,
})
}
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.')
}
public async fetchGasPriceFromRpc(): Promise<number> {
try {
const { status, data } = await this.fetcher.makeRpcCall<{ result: string | number }>({
params: [],
method: 'eth_gasPrice',
})
if (status === 200) {
return LegacyGasPriceOracle.getGasPriceFromResponse({
fetcherName: 'Default RPC',
response: data.result,
})
}
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.')
}
}
public async fetchGasPricesOffChain(shouldGetMedian = true): Promise<GasPrice> {
if (shouldGetMedian) {
return await this.fetchMedianGasPriceOffChain()
}
for (const oracle of Object.values(this.offChainOracles)) {
try {
return await this.askOracle(oracle)
} catch (e) {
console.info(`${oracle} has error - `, e.message)
continue
}
}
throw new Error('All oracles are down. Probably a network error.')
}
public async fetchMedianGasPriceOffChain(): Promise<GasPrice> {
const promises: Promise<GasPrice>[] = []
for (const oracle of Object.values(this.offChainOracles) as OffChainOracle[]) {
promises.push(this.askOracle(oracle))
}
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 LegacyGasPriceOracle.getMedianGasPrice(allGasPrices)
}
public async gasPrices(fallbackGasPrices?: GasPrice, shouldGetMedian = true): Promise<GasPrice> {
if (!this.lastGasPrice) {
this.lastGasPrice = fallbackGasPrices || this.configuration.fallbackGasPrices
}
const cacheKey = this.LEGACY_KEY(this.configuration.chainId)
const cachedFees = await this.cache.get(cacheKey)
if (cachedFees) {
return cachedFees
}
if (Object.keys(this.offChainOracles).length > 0) {
try {
this.lastGasPrice = await this.fetchGasPricesOffChain(shouldGetMedian)
if (this.configuration.shouldCache) {
await this.cache.set(cacheKey, this.lastGasPrice)
}
return this.lastGasPrice
} catch (e) {
console.error('Failed to fetch gas prices from offchain oracles...')
}
}
if (Object.keys(this.onChainOracles).length > 0) {
try {
const fastGas = await this.fetchGasPricesOnChain()
this.lastGasPrice = LegacyGasPriceOracle.getCategorize(fastGas)
if (this.configuration.shouldCache) {
await this.cache.set(cacheKey, this.lastGasPrice)
}
return this.lastGasPrice
} catch (e) {
console.error('Failed to fetch gas prices from onchain oracles...')
}
}
try {
const fastGas = await this.fetchGasPriceFromRpc()
this.lastGasPrice = LegacyGasPriceOracle.getCategorize(fastGas)
if (this.configuration.shouldCache) {
await this.cache.set(cacheKey, this.lastGasPrice)
}
return this.lastGasPrice
} catch (e) {
console.error('Failed to fetch gas prices from default RPC. Last known gas will be returned')
}
return LegacyGasPriceOracle.normalize(this.lastGasPrice)
}
public async askOracle(oracle: OffChainOracle): Promise<GasPrice> {
const {
url,
name,
denominator,
lowPropertyName,
fastPropertyName,
instantPropertyName,
standardPropertyName,
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`)
}
const gasPrices: GasPrice = {
instant: parseFloat(gas[instantPropertyName]) / denominator,
fast: parseFloat(gas[fastPropertyName]) / denominator,
standard: parseFloat(gas[standardPropertyName]) / denominator,
low: parseFloat(gas[lowPropertyName]) / denominator,
}
return LegacyGasPriceOracle.normalize(gasPrices)
} else {
throw new Error(`Fetch gasPrice from ${name} oracle failed. Trying another one...`)
}
}
}

@ -0,0 +1,80 @@
import { RpcFetcher } from '@/services'
export type OffChainOracle = {
url: string
name: string
denominator: number
lowPropertyName: string
fastPropertyName: string
instantPropertyName: string
standardPropertyName: string
additionalDataProperty: string | null
}
export type OffChainOracles = Record<string, OffChainOracle>
export type OnChainOracle = {
name: string
rpc?: string
contract: string
callData: string
denominator: string
}
export type OnChainOracles = Record<string, OnChainOracle>
export type AllOracles = {
onChainOracles: OnChainOracles
offChainOracles: OffChainOracles
}
export type NetworkConfig = Record<number, AllOracles>
export type GasPriceKey = 'instant' | 'fast' | 'standard' | 'low'
export type GasPrice = Record<GasPriceKey, number>
export type LegacyOptions = {
chainId?: number
timeout?: number
blockTime?: number
defaultRpc?: string
shouldCache?: boolean
fallbackGasPrices?: GasPrice
}
export type LegacyOptionsPayload = LegacyOptions & {
fetcher: RpcFetcher
}
export type GetGasPriceFromRespInput = {
fetcherName: string
response: string | number
denominator?: number | string
}
type Config = Required<LegacyOptions>
export abstract class LegacyOracle {
static normalize: (_gas: GasPrice) => GasPrice
static getCategorize: (gasPrice: number) => GasPrice
static getMultipliedPrices: (gasPrice: number) => GasPrice
static getMedianGasPrice: (gasPrices: GasPrice[]) => GasPrice
static getGasPriceFromResponse: (payload: GetGasPriceFromRespInput) => Promise<number>
public configuration: Config
public lastGasPrice: GasPrice
public onChainOracles: OnChainOracles
public offChainOracles: OffChainOracles
public abstract removeOnChainOracle(name: string): void
public abstract removeOffChainOracle(name: string): void
public abstract addOnChainOracle(oracle: OnChainOracle): void
public abstract addOffChainOracle(oracle: OffChainOracle): void
public fetchGasPriceFromRpc: () => Promise<number>
public fetchGasPricesOnChain: () => Promise<number>
public fetchMedianGasPriceOffChain: () => Promise<GasPrice>
public askOracle: (oracle: OffChainOracle) => Promise<GasPrice>
public fetchGasPricesOffChain: (shouldGetMedian?: boolean) => Promise<GasPrice>
public gasPrices: (fallbackGasPrices?: GasPrice, shouldGetMedian?: boolean) => Promise<GasPrice>
}

@ -0,0 +1,23 @@
import axios, { AxiosResponse } from 'axios'
import { MakeRpcCallInput } from './types'
export class RpcFetcher {
private readonly rpc: string
private readonly timeout: number
constructor(rpc: string, timeout: number) {
this.rpc = rpc
this.timeout = timeout
}
public async makeRpcCall<R>({ rpc, timeout, method, params }: MakeRpcCallInput): Promise<AxiosResponse<R>> {
const body = {
method,
id: 1337,
jsonrpc: '2.0',
params: params,
}
return await axios.post<R>(rpc || this.rpc, body, { timeout: timeout || this.timeout })
}
}

@ -0,0 +1,2 @@
export * from './fetcher'
export * from './types'

@ -0,0 +1,7 @@
export type Params = (string | number | number[] | Record<string, string | number | boolean> | boolean)[]
export type MakeRpcCallInput = {
rpc?: string
method: string
timeout?: number
params: Params
}

@ -0,0 +1,134 @@
/* eslint-disable @typescript-eslint/no-var-requires */
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import chai from 'chai'
import BigNumber from 'bignumber.js'
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import mockery from 'mockery'
import { before, describe } from 'mocha'
import { GWEI_PRECISION } from '@/constants'
import { GasPriceOracle, GasPrice } from '@/services'
chai.use(require('chai-as-promised'))
chai.should()
let oracle = new GasPriceOracle()
before('before', async () => {
const gasPrice = await oracle.legacy.gasPrices()
console.log('legacy gasPrice - ', { gasPrice })
})
before('before', function () {
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('axios', axiosMock)
})
beforeEach('beforeEach', function () {
oracle = new GasPriceOracle()
})
const INJECTED_CHAIN_ID = 5
const INJECTED_RPC_URL = 'https://rpc.goerli.mudit.blog/'
describe('complex test', function () {
describe('fetching data', function () {
describe('should work with unexpected chainId', function () {
// it('legacy', async function () {
// const newOracle = new GasPriceOracle({ chainId: ChainId.XDAI })
//
// for (let i = 0; i < 100; i++) {
// const res = await newOracle.eip1559.estimateFees()
// await new Promise((r) =>
// setTimeout(() => {
// r(console.log(`res - ${i}`, res))
// }, 3000),
// )
// }
// })
it('legacy', async function () {
const newOracle = new GasPriceOracle({ timeout: 1337, chainId: INJECTED_CHAIN_ID, defaultRpc: INJECTED_RPC_URL })
const goerliGas = (await newOracle.gasPrices({ isLegacy: true })) as unknown as GasPrice
if ('instant' in goerliGas) {
goerliGas.instant.should.be.a('number')
goerliGas.fast.should.be.a('number')
goerliGas.standard.should.be.a('number')
goerliGas.low.should.be.a('number')
}
newOracle.legacy.configuration.defaultRpc.should.be.equal(INJECTED_RPC_URL)
newOracle.legacy.configuration.chainId.should.be.equal(INJECTED_CHAIN_ID)
})
it('eip-1559', async function () {
const newOracle = new GasPriceOracle({ timeout: 1337, chainId: INJECTED_CHAIN_ID, defaultRpc: INJECTED_RPC_URL })
const goerliEstimated = await newOracle.eip1559.estimateFees()
if (goerliEstimated.baseFee) {
goerliEstimated.baseFee.should.be.a('number')
goerliEstimated.maxFeePerGas.should.be.at.least(goerliEstimated.baseFee)
const estimatedMaxFee = new BigNumber(goerliEstimated.baseFee)
.plus(goerliEstimated.maxPriorityFeePerGas)
.decimalPlaces(GWEI_PRECISION)
.toNumber()
goerliEstimated.maxFeePerGas.should.be.at.equal(estimatedMaxFee)
}
goerliEstimated.maxFeePerGas.should.be.a('number')
goerliEstimated.maxPriorityFeePerGas.should.be.a('number')
newOracle.legacy.configuration.defaultRpc.should.be.equal(INJECTED_RPC_URL)
newOracle.legacy.configuration.chainId.should.be.equal(INJECTED_CHAIN_ID)
})
it('without selected strategy', async function () {
const newOracle = new GasPriceOracle({ timeout: 1337, chainId: INJECTED_CHAIN_ID, defaultRpc: INJECTED_RPC_URL })
const gasPrice = await newOracle.gasPrices({})
if ('baseFee' in gasPrice && gasPrice.baseFee) {
gasPrice.baseFee.should.be.a('number')
gasPrice.maxFeePerGas.should.be.at.least(gasPrice.baseFee)
const estimatedMaxFee = new BigNumber(gasPrice.baseFee)
.plus(gasPrice.maxPriorityFeePerGas)
.decimalPlaces(GWEI_PRECISION)
.toNumber()
gasPrice.maxFeePerGas.should.be.at.equal(estimatedMaxFee)
}
if ('maxFeePerGas' in gasPrice) {
gasPrice.maxFeePerGas.should.be.a('number')
gasPrice.maxPriorityFeePerGas.should.be.a('number')
}
if ('instant' in gasPrice) {
gasPrice.instant.should.be.a('number')
gasPrice.fast.should.be.a('number')
gasPrice.standard.should.be.a('number')
gasPrice.low.should.be.a('number')
}
newOracle.legacy.configuration.defaultRpc.should.be.equal(INJECTED_RPC_URL)
newOracle.legacy.configuration.chainId.should.be.equal(INJECTED_CHAIN_ID)
})
})
})
})
after('after', function () {
after(function () {
mockery.disable()
mockery.deregisterMock('node-fetch')
})
})

@ -0,0 +1,163 @@
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import chai from 'chai'
import BigNumber from 'bignumber.js'
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import chaiAsPromised from 'chai-as-promised'
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import mockery from 'mockery'
import { before, describe } from 'mocha'
import { sleep } from '@/utils'
import { ChainId, NETWORKS } from '@/config'
import { GWEI_PRECISION } from '@/constants'
import { GasPriceOracle } from '@/services/gas-price-oracle'
import { EstimatedGasPrice } from '@/services/gas-estimation'
import { FALLBACK_ESTIMATE } from '@/services/gas-estimation/constants'
chai.use(chaiAsPromised)
chai.should()
let oracle = new GasPriceOracle()
before('before', async () => {
const gasPrice = await oracle.eip1559.estimateFees()
console.log('eip estimation -', { gasPrice })
})
//
beforeEach('beforeEach', function () {
oracle = new GasPriceOracle()
})
const INJECTED_RPC_URL = 'https://cloudflare-eth.com'
describe('eip-1559 gasOracle', function () {
describe('eip constructor', function () {
it('should set default values', function () {
oracle.eip1559.configuration.blocksCount.should.be.equal(NETWORKS[oracle.eip1559.configuration.chainId].blocksCount)
oracle.eip1559.configuration.percentile.should.be.equal(NETWORKS[oracle.eip1559.configuration.chainId].percentile)
})
it('should set passed values', function () {
const newHistoryBlocks = 15
const newHistoryPercentile = 10
const newOracle = new GasPriceOracle({
blocksCount: newHistoryBlocks,
percentile: newHistoryPercentile,
})
newOracle.eip1559.configuration.blocksCount.should.be.equal(newHistoryBlocks)
newOracle.eip1559.configuration.percentile.should.be.equal(newHistoryPercentile)
})
})
const chains = Object.keys(NETWORKS).map((id) => Number(id))
chains.forEach((chainId) => {
let eipOracle = new GasPriceOracle({ chainId })
describe(`estimateGas ${chainId}`, function () {
it('should return error if not eip-1559 not supported', async function () {
if (chainId === ChainId.OPTIMISM || chainId === ChainId.BSC) {
await eipOracle.eip1559
.estimateFees()
.should.be.rejectedWith('An error occurred while fetching current base fee, falling back')
}
})
if (chainId === ChainId.OPTIMISM || chainId === ChainId.BSC) {
return
}
it('should work', async function () {
const estimateGas: EstimatedGasPrice = await eipOracle.eip1559.estimateFees()
console.log(`estimateGas ${chainId}`, estimateGas)
if (estimateGas.baseFee) {
estimateGas.baseFee.should.be.a('number')
estimateGas.maxFeePerGas.should.be.a('number')
estimateGas.maxPriorityFeePerGas.should.be.a('number')
estimateGas.maxFeePerGas.should.be.at.least(estimateGas.baseFee)
const estimatedMaxFee = new BigNumber(estimateGas.baseFee)
.plus(estimateGas.maxPriorityFeePerGas)
.decimalPlaces(GWEI_PRECISION)
.toNumber()
estimateGas.maxFeePerGas.should.be.at.equal(estimatedMaxFee)
}
})
it('should work with crashed rpc (return default data)', async function () {
eipOracle = new GasPriceOracle({ defaultRpc: 'wrongRpcUrl', chainId })
const estimateGas: EstimatedGasPrice = await eipOracle.eip1559.estimateFees(FALLBACK_ESTIMATE)
if (estimateGas.baseFee) {
estimateGas.baseFee.should.be.a('number')
estimateGas.maxFeePerGas.should.be.a('number')
estimateGas.maxPriorityFeePerGas.should.be.a('number')
estimateGas.baseFee.should.be.at.equal(FALLBACK_ESTIMATE.baseFee)
estimateGas.maxFeePerGas.should.be.at.equal(FALLBACK_ESTIMATE.maxFeePerGas)
estimateGas.maxPriorityFeePerGas.should.be.at.equal(FALLBACK_ESTIMATE.maxPriorityFeePerGas)
}
})
it('should work with custom rpc', async function () {
eipOracle = new GasPriceOracle({ defaultRpc: INJECTED_RPC_URL, chainId })
const estimateGas: EstimatedGasPrice = await eipOracle.eip1559.estimateFees(FALLBACK_ESTIMATE)
if (estimateGas.baseFee) {
estimateGas.baseFee.should.be.a('number')
estimateGas.maxFeePerGas.should.be.a('number')
estimateGas.maxPriorityFeePerGas.should.be.a('number')
const estimatedMaxFee = new BigNumber(estimateGas.baseFee)
.plus(estimateGas.maxPriorityFeePerGas)
.decimalPlaces(GWEI_PRECISION)
.toNumber()
estimateGas.maxFeePerGas.should.be.at.least(estimateGas.baseFee)
estimateGas.maxFeePerGas.should.be.at.equal(estimatedMaxFee)
}
})
it('should cache', async function () {
eipOracle = new GasPriceOracle({ shouldCache: true, chainId })
const estimateGasFirst: EstimatedGasPrice = await eipOracle.eip1559.estimateFees()
await sleep(2000)
const estimateGasSecond: EstimatedGasPrice = await eipOracle.eip1559.estimateFees()
if (estimateGasFirst?.maxFeePerGas) {
estimateGasFirst.maxFeePerGas.should.be.at.equal(estimateGasSecond?.maxFeePerGas)
}
await sleep(4000)
const estimateGasThird: EstimatedGasPrice = await eipOracle.eip1559.estimateFees()
if (estimateGasSecond?.maxFeePerGas) {
estimateGasSecond.maxFeePerGas.should.be.at.equal(estimateGasThird?.maxFeePerGas)
}
})
})
})
describe('estimate ARBITRUM', function () {
it('should be priority 0', async function () {
const eipOracle = new GasPriceOracle({ minPriority: 0, chainId: ChainId.ARBITRUM })
const estimateGas: EstimatedGasPrice = await eipOracle.eip1559.estimateFees(FALLBACK_ESTIMATE)
console.log('estimateGas.maxPriorityFeePerGas', estimateGas.maxPriorityFeePerGas)
estimateGas.maxPriorityFeePerGas.should.be.at.equal(0)
})
})
})
after('after', function () {
after(function () {
mockery.disable()
mockery.deregisterMock('node-fetch')
})
})

@ -0,0 +1,383 @@
/* eslint-disable @typescript-eslint/no-var-requires */
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import chai from 'chai'
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import mockery from 'mockery'
import BigNumber from 'bignumber.js'
import { before, describe } from 'mocha'
import { sleep } from '@/utils'
import { ChainId, NETWORKS } from '@/config'
import { DEFAULT_TIMEOUT } from '@/constants'
import { GasPriceOracle } from '@/services/gas-price-oracle'
import { GasPrice, LegacyGasPriceOracle, OffChainOracle } from '@/services/legacy-gas-price'
chai.use(require('chai-as-promised'))
chai.should()
let oracle = new GasPriceOracle()
let { onChainOracles, offChainOracles } = oracle.legacy
before('before', async () => {
const gasPrice = await oracle.legacy.gasPrices()
console.log('legacy gasPrice - ', { gasPrice })
})
before('before', function () {
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('axios', axiosMock)
})
beforeEach('beforeEach', function () {
oracle = new GasPriceOracle()
;({ onChainOracles, offChainOracles } = oracle.legacy)
})
const INJECTED_RPC_URL = 'https://cloudflare-eth.com'
describe('legacy gasOracle', function () {
describe('legacy constructor', function () {
it('should set default values', function () {
oracle.legacy.configuration.defaultRpc.should.be.equal(NETWORKS[ChainId.MAINNET].rpcUrl)
oracle.legacy.configuration.timeout.should.be.equal(DEFAULT_TIMEOUT)
})
it('should set passed values', function () {
const newOracle = new GasPriceOracle({ timeout: 1337 })
newOracle.legacy.configuration.defaultRpc.should.be.equal(NETWORKS[ChainId.MAINNET].rpcUrl)
newOracle.legacy.configuration.timeout.should.be.equal(1337)
})
})
describe('fetchGasPricesOffChain', function () {
it('should work', async function () {
const gas: GasPrice = await oracle.legacy.fetchGasPricesOffChain(true)
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)
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 throw if all offchain oracles are down', async function () {
mockery.enable({ useCleanCache: true, warnOnUnregistered: false })
const { GasPriceOracle } = require('../index')
oracle = new GasPriceOracle()
// @ts-ignore
await oracle.legacy.fetchGasPricesOffChain(true).should.be.rejectedWith('All oracles are down. Probably a network error.')
mockery.disable()
})
})
describe('fetchGasPricesOnChain', function () {
it('should work', async function () {
const gas: number = await oracle.legacy.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 = INJECTED_RPC_URL
oracle = new GasPriceOracle({ defaultRpc: rpc })
oracle.legacy.configuration.defaultRpc.should.be.equal(rpc)
const gas: number = await oracle.legacy.fetchGasPricesOnChain()
gas.should.be.a('number')
gas.should.be.above(1)
gas.should.not.be.equal(0)
})
it('should remove oracle', async function () {
await oracle.legacy.fetchGasPricesOnChain()
oracle.legacy.removeOnChainOracle('chainlink')
// @ts-ignore
await oracle.legacy.fetchGasPricesOnChain().should.be.rejectedWith('All oracles are down. Probably a network error.')
})
it('should add oracle', async function () {
const toAdd = onChainOracles.chainlink
await oracle.legacy.fetchGasPricesOnChain()
oracle.legacy.removeOnChainOracle('chainlink')
// @ts-ignore
await oracle.legacy.fetchGasPricesOnChain().should.be.rejectedWith('All oracles are down. Probably a network error.')
oracle.legacy.addOnChainOracle(toAdd)
const gas: number = await oracle.legacy.fetchGasPricesOnChain()
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('../index')
oracle = new GasPriceOracle()
// @ts-ignore
await oracle.legacy.fetchGasPricesOnChain().should.be.rejectedWith('All oracles are down. Probably a network error.')
mockery.disable()
})
})
describe('fetchGasPriceFromRpc', function () {
it('should work', async function () {
const gas: number = await oracle.legacy.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 = INJECTED_RPC_URL
const oracle = new GasPriceOracle({ defaultRpc: rpc })
oracle.legacy.configuration.defaultRpc.should.be.equal(rpc)
const gas: number = await oracle.legacy.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('../index')
oracle = new GasPriceOracle()
// @ts-ignore
await oracle.legacy.fetchGasPriceFromRpc().should.be.rejectedWith('Default RPC is down. Probably a network error.')
mockery.disable()
})
})
describe('legacy gasPrice', function () {
it('should work', async function () {
const gas = (await oracle.gasPrices({ isLegacy: true })) as unknown as GasPrice
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)
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('../index')
oracle = new GasPriceOracle()
const gas = (await oracle.gasPrices({ isLegacy: true })) as unknown as GasPrice
const shouldBe = LegacyGasPriceOracle.getCategorize(NETWORKS[ChainId.MAINNET].defaultGasPrice)
gas.instant.should.be.equal(shouldBe.instant)
gas.fast.should.be.equal(shouldBe.fast)
gas.standard.should.be.equal(shouldBe.standard)
gas.low.should.be.equal(shouldBe.low)
mockery.disable()
})
it('should fallback to set values', async function () {
mockery.enable({ useCleanCache: true, warnOnUnregistered: false })
const { GasPriceOracle } = require('../index')
oracle = new GasPriceOracle()
const fallbackGasPrices = {
gasPrices: {
instant: 50,
fast: 21,
standard: 10,
low: 3,
},
}
const gas = (await oracle.gasPrices({ isLegacy: true, fallbackGasPrices })) as unknown as GasPrice
gas.instant.should.be.equal(fallbackGasPrices.gasPrices.instant)
gas.fast.should.be.equal(fallbackGasPrices.gasPrices.fast)
gas.standard.should.be.equal(fallbackGasPrices.gasPrices.standard)
gas.low.should.be.equal(fallbackGasPrices.gasPrices.low)
mockery.disable()
})
it('should cache', async function () {
const oracle = new GasPriceOracle({ shouldCache: true })
const gasPricesFirst = await oracle.legacy.gasPrices()
await sleep(2000)
const gasPricesSecond = await oracle.legacy.gasPrices()
if (gasPricesFirst.fast) {
gasPricesFirst.fast.should.be.at.equal(gasPricesSecond?.fast)
}
await sleep(4000)
const gasPricesThird = await oracle.legacy.gasPrices()
if (gasPricesSecond.fast) {
gasPricesSecond.fast.should.be.at.equal(gasPricesThird?.fast)
}
})
})
describe('median', function () {
it('should work', 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 = LegacyGasPriceOracle.getMedianGasPrice([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 = LegacyGasPriceOracle.getMedianGasPrice([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.legacy.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)
gas.fast.should.be.at.least(gas.standard)
gas.standard.should.be.at.least(gas.low)
gas.low.should.not.be.equal(0)
})
})
describe('normalize result values', function () {
const wrongDecimalsGas = {
gasPrices: {
instant: 1.1,
fast: 2.12345678901,
standard: 3.12345678901,
low: 3.12345679,
},
}
const checkDecimals = (gas: GasPrice) => {
const gasPrices: number[] = Object.values(gas)
for (const gas of gasPrices) {
new BigNumber(gas).dp().should.be.at.most(9)
}
}
it('default fallback should be normalized', function () {
mockery.enable({ useCleanCache: true, warnOnUnregistered: false })
oracle = new GasPriceOracle({ fallbackGasPrices: wrongDecimalsGas })
checkDecimals(oracle.legacy.configuration.fallbackGasPrices)
mockery.disable()
})
it('fallback should be normalized', async function () {
mockery.enable({ useCleanCache: true, warnOnUnregistered: false })
const { GasPriceOracle } = require('../index')
oracle = new GasPriceOracle()
const gas = await oracle.legacy.gasPrices(wrongDecimalsGas.gasPrices)
checkDecimals(gas)
mockery.disable()
})
it('rpc fallback should be normalized', async function () {
oracle = new GasPriceOracle({ chainId: 42161, defaultRpc: 'https://arb1.arbitrum.io/rpc' })
const gas = await oracle.legacy.gasPrices()
checkDecimals(gas)
})
})
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.legacy)
for (const o of Object.values(offChainOracles) as OffChainOracle[]) {
it(`check ${o.name}`, async function () {
try {
const gas: GasPrice = await oracle.legacy.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)
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 () {
after(function () {
mockery.disable()
mockery.deregisterMock('node-fetch')
})
})

@ -0,0 +1,40 @@
import { AllOracles } from './services/legacy-gas-price'
export interface Block {
baseFeePerGas: string
difficulty: string
extraData: string
gasLimit: string
gasUsed: string
hash: string
miner: string
mixHash: string
nonce: string
number: string
parentHash: string
receiptsRoot: string
sha3Uncles: string
size: string
stateRoot: string
timestamp: string
totalDifficulty: string
transactions: unknown[]
transactionsRoot: string
uncles: unknown[]
}
export interface FeeHistory {
baseFeePerGas: string[]
gasUsedRatio: number[]
reward?: string[][]
oldestBlock: string
}
export type NetworksConfig = {
oracles: AllOracles
rpcUrl: string
defaultGasPrice: number
maxGasPrice: number
blocksCount: number
percentile: number
}

@ -0,0 +1,20 @@
import BigNumber from 'bignumber.js'
import { GWEI, GWEI_PRECISION } from '@/constants'
const toGwei = (amount: number | string | BigNumber): BigNumber => {
return new BigNumber(amount).multipliedBy(GWEI).decimalPlaces(GWEI_PRECISION)
}
const fromWeiToGwei = (amount: number | string | BigNumber): BigNumber => {
return new BigNumber(amount).dividedBy(GWEI).decimalPlaces(GWEI_PRECISION)
}
const fromNumberToHex = (amount: number | string | BigNumber): string => {
return `0x${new BigNumber(amount).toString(16)}`
}
const fromGweiToWeiHex = (value: number): string => {
return fromNumberToHex(new BigNumber(value).multipliedBy(GWEI).decimalPlaces(0))
}
export { toGwei, fromWeiToGwei, fromGweiToWeiHex, fromNumberToHex }

@ -0,0 +1,8 @@
export * from './math'
export * from './crypto'
const sleep = (time: number): Promise<boolean> => {
return new Promise((res) => setTimeout(() => res(true), time))
}
export { sleep }

@ -0,0 +1,45 @@
import BigNumber from 'bignumber.js'
import { BG_ZERO, PERCENT_MULTIPLIER } from '@/constants'
import { toGwei } from './crypto'
type FindMaxRes = {
highest: BigNumber
index: number
}
const findMax = (values: BigNumber[]): FindMaxRes => {
return values.reduce(
(acc, curr, index) => {
const isGreaterThanAcc = curr.isGreaterThan(acc.highest)
if (isGreaterThanAcc) {
acc.highest = curr
acc.index = index
}
return acc
},
{
highest: BG_ZERO,
index: 0,
},
)
}
const getMedian = <T>(arr: T[]): number => {
return Math.floor(arr.length / 2)
}
const round = (value: number | string | BigNumber): BigNumber => {
return new BigNumber(value).decimalPlaces(0, 2)
}
const roundGwei = (value: number | string | BigNumber): BigNumber => {
return toGwei(value).decimalPlaces(0, 2)
}
const bumpOnPercent = (value: number, bumpPercent: number): number => {
return value + (value * bumpPercent) / PERCENT_MULTIPLIER
}
export { findMax, getMedian, round, roundGwei, bumpOnPercent }

@ -0,0 +1,9 @@
{
"extends": "./tsconfig",
"compilerOptions": {
"declaration": false,
"target": "es2015",
"module": "es2015",
"outDir": "lib/esm"
}
}

@ -0,0 +1,33 @@
{
"compilerOptions": {
"target": "es5",
"module": "commonjs",
"moduleResolution": "node",
"lib": ["es5", "es6", "es2021", "esnext"],
"experimentalDecorators": true,
"sourceMap": true,
"outDir": "lib",
"noImplicitAny": true,
"allowJs": true,
"declaration": true,
"skipLibCheck": true,
"esModuleInterop": true,
"checkJs": false,
"noUnusedLocals": true,
"strictNullChecks": true,
"noImplicitThis": true,
"noImplicitReturns": true,
"allowSyntheticDefaultImports": true,
"strictFunctionTypes": true,
"forceConsistentCasingInFileNames": true,
"resolveJsonModule": true,
"isolatedModules": true,
"baseUrl": ".",
"paths": {
"@/*": ["./src/*"]
},
"types": ["@types/node"]
},
"include": ["src/**/*"],
"exclude": ["node_modules", "src/tests"]
}

28960
yarn.lock

File diff suppressed because it is too large Load Diff