mirror of
https://github.com/kremalicious/metamask-extension.git
synced 2024-12-23 09:52:26 +01:00
176 lines
6.5 KiB
JavaScript
176 lines
6.5 KiB
JavaScript
import ObservableStore from 'obs-store'
|
|
import EthQuery from 'eth-query'
|
|
import log from 'loglevel'
|
|
import pify from 'pify'
|
|
import { ROPSTEN, RINKEBY, KOVAN, MAINNET, GOERLI } from './network/enums'
|
|
|
|
const INFURA_PROVIDER_TYPES = [ROPSTEN, RINKEBY, KOVAN, MAINNET, GOERLI]
|
|
|
|
export default class RecentBlocksController {
|
|
|
|
/**
|
|
* Controller responsible for storing, updating and managing the recent history of blocks. Blocks are back filled
|
|
* upon the controller's construction and then the list is updated when the given block tracker gets a 'latest' event
|
|
* (indicating that there is a new block to process).
|
|
*
|
|
* @typedef {Object} RecentBlocksController
|
|
* @param {Object} opts - Contains objects necessary for tracking blocks and querying the blockchain
|
|
* @param {BlockTracker} opts.blockTracker Contains objects necessary for tracking blocks and querying the blockchain
|
|
* @param {BlockTracker} opts.provider The provider used to create a new EthQuery instance.
|
|
* @property {BlockTracker} blockTracker Points to the passed BlockTracker. On RecentBlocksController construction,
|
|
* listens for 'latest' events so that new blocks can be processed and added to storage.
|
|
* @property {EthQuery} ethQuery Points to the EthQuery instance created with the passed provider
|
|
* @property {number} historyLength The maximum length of blocks to track
|
|
* @property {object} store Stores the recentBlocks
|
|
* @property {array} store.recentBlocks Contains all recent blocks, up to a total that is equal to this.historyLength
|
|
*
|
|
*/
|
|
constructor (opts = {}) {
|
|
const { blockTracker, provider, networkController } = opts
|
|
this.blockTracker = blockTracker
|
|
this.ethQuery = new EthQuery(provider)
|
|
this.historyLength = opts.historyLength || 40
|
|
|
|
const initState = Object.assign({
|
|
recentBlocks: [],
|
|
}, opts.initState)
|
|
this.store = new ObservableStore(initState)
|
|
const blockListner = async (newBlockNumberHex) => {
|
|
try {
|
|
await this.processBlock(newBlockNumberHex)
|
|
} catch (err) {
|
|
log.error(err)
|
|
}
|
|
}
|
|
let isListening = false
|
|
const { type } = networkController.getProviderConfig()
|
|
if (!INFURA_PROVIDER_TYPES.includes(type) && type !== 'loading') {
|
|
this.blockTracker.on('latest', blockListner)
|
|
isListening = true
|
|
}
|
|
networkController.on('networkDidChange', (newType) => {
|
|
if (INFURA_PROVIDER_TYPES.includes(newType) && isListening) {
|
|
this.blockTracker.removeListener('latest', blockListner)
|
|
} else if (
|
|
!INFURA_PROVIDER_TYPES.includes(type) &&
|
|
type !== 'loading' &&
|
|
!isListening
|
|
) {
|
|
this.blockTracker.on('latest', blockListner)
|
|
|
|
}
|
|
})
|
|
this.backfill()
|
|
}
|
|
|
|
/**
|
|
* Receives a new block and modifies it with this.mapTransactionsToPrices. Then adds that block to the recentBlocks
|
|
* array in storage. If the recentBlocks array contains the maximum number of blocks, the oldest block is removed.
|
|
*
|
|
* @param {Object} newBlock - The new block to modify and add to the recentBlocks array
|
|
*
|
|
*/
|
|
async processBlock (newBlockNumberHex) {
|
|
const newBlockNumber = Number.parseInt(newBlockNumberHex, 16)
|
|
const newBlock = await this.getBlockByNumber(newBlockNumber)
|
|
if (!newBlock) {
|
|
return
|
|
}
|
|
|
|
const block = this.mapTransactionsToPrices(newBlock)
|
|
|
|
const state = this.store.getState()
|
|
state.recentBlocks.push(block)
|
|
|
|
while (state.recentBlocks.length > this.historyLength) {
|
|
state.recentBlocks.shift()
|
|
}
|
|
|
|
this.store.updateState(state)
|
|
}
|
|
|
|
/**
|
|
* Receives a new block and modifies it with this.mapTransactionsToPrices. Adds that block to the recentBlocks
|
|
* array in storage, but only if the recentBlocks array contains fewer than the maximum permitted.
|
|
*
|
|
* Unlike this.processBlock, backfillBlock adds the modified new block to the beginning of the recent block array.
|
|
*
|
|
* @param {Object} newBlock - The new block to modify and add to the beginning of the recentBlocks array
|
|
*
|
|
*/
|
|
backfillBlock (newBlock) {
|
|
const block = this.mapTransactionsToPrices(newBlock)
|
|
|
|
const state = this.store.getState()
|
|
|
|
if (state.recentBlocks.length < this.historyLength) {
|
|
state.recentBlocks.unshift(block)
|
|
}
|
|
|
|
this.store.updateState(state)
|
|
}
|
|
|
|
/**
|
|
* Receives a block and gets the gasPrice of each of its transactions. These gas prices are added to the block at a
|
|
* new property, and the block's transactions are removed.
|
|
*
|
|
* @param {Object} newBlock - The block to modify. It's transaction array will be replaced by a gasPrices array.
|
|
* @returns {Object} - The modified block.
|
|
*
|
|
*/
|
|
mapTransactionsToPrices (newBlock) {
|
|
const block = {
|
|
...newBlock,
|
|
gasPrices: newBlock.transactions.map((tx) => {
|
|
return tx.gasPrice
|
|
}),
|
|
}
|
|
delete block.transactions
|
|
return block
|
|
}
|
|
|
|
/**
|
|
* On this.blockTracker's first 'latest' event after this RecentBlocksController's instantiation, the store.recentBlocks
|
|
* array is populated with this.historyLength number of blocks. The block number of the this.blockTracker's first
|
|
* 'latest' event is used to iteratively generate all the numbers of the previous blocks, which are obtained by querying
|
|
* the blockchain. These blocks are backfilled so that the recentBlocks array is ordered from oldest to newest.
|
|
*
|
|
* Each iteration over the block numbers is delayed by 100 milliseconds.
|
|
*
|
|
* @returns {Promise<void>} - Promises undefined
|
|
*/
|
|
async backfill () {
|
|
this.blockTracker.once('latest', async (blockNumberHex) => {
|
|
const currentBlockNumber = Number.parseInt(blockNumberHex, 16)
|
|
const blocksToFetch = Math.min(currentBlockNumber, this.historyLength)
|
|
const prevBlockNumber = currentBlockNumber - 1
|
|
const targetBlockNumbers = Array(blocksToFetch).fill().map((_, index) => prevBlockNumber - index)
|
|
await Promise.all(targetBlockNumbers.map(async (targetBlockNumber) => {
|
|
try {
|
|
const newBlock = await this.getBlockByNumber(targetBlockNumber)
|
|
if (!newBlock) {
|
|
return
|
|
}
|
|
|
|
this.backfillBlock(newBlock)
|
|
} catch (e) {
|
|
log.error(e)
|
|
}
|
|
}))
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Uses EthQuery to get a block that has a given block number.
|
|
*
|
|
* @param {number} number - The number of the block to get
|
|
* @returns {Promise<object>} - Promises A block with the passed number
|
|
*
|
|
*/
|
|
async getBlockByNumber (number) {
|
|
const blockNumberHex = '0x' + number.toString(16)
|
|
return await pify(this.ethQuery.getBlockByNumber).call(this.ethQuery, blockNumberHex, true)
|
|
}
|
|
|
|
}
|