@metamask/gas-fee-controller 1.0.0

package/dist/determineGasFeeCalculations.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const GasFeeController_1 = require("./GasFeeController");
+/**
+ * Obtains a set of max base and priority fee estimates along with time estimates so that we
+ * can present them to users when they are sending transactions or making swaps.
+ *
+ * @param args - The arguments.
+ * @param args.isEIP1559Compatible - Governs whether or not we can use an EIP-1559-only method to
+ * produce estimates.
+ * @param args.isLegacyGasAPICompatible - Governs whether or not we can use a non-EIP-1559 method to
+ * produce estimates (for instance, testnets do not support estimates altogether).
+ * @param args.fetchGasEstimates - A function that fetches gas estimates using an EIP-1559-specific
+ * API.
+ * @param args.fetchGasEstimatesUrl - The URL for the API we can use to obtain EIP-1559-specific
+ * estimates.
+ * @param args.fetchGasEstimatesViaEthFeeHistory - A function that fetches gas estimates using
+ * `eth_feeHistory` (an EIP-1559 feature).
+ * @param args.fetchLegacyGasPriceEstimates - A function that fetches gas estimates using an
+ * non-EIP-1559-specific API.
+ * @param args.fetchLegacyGasPriceEstimatesUrl - The URL for the API we can use to obtain
+ * non-EIP-1559-specific estimates.
+ * @param args.fetchEthGasPriceEstimate - A function that fetches gas estimates using
+ * `eth_gasPrice`.
+ * @param args.calculateTimeEstimate - A function that determine time estimate bounds.
+ * @param args.clientId - An identifier that an API can use to know who is asking for estimates.
+ * @param args.ethQuery - An EthQuery instance we can use to talk to Ethereum directly.
+ * @returns The gas fee calculations.
+ */
+function determineGasFeeCalculations({ isEIP1559Compatible, isLegacyGasAPICompatible, fetchGasEstimates, fetchGasEstimatesUrl, fetchGasEstimatesViaEthFeeHistory, fetchLegacyGasPriceEstimates, fetchLegacyGasPriceEstimatesUrl, fetchEthGasPriceEstimate, calculateTimeEstimate, clientId, ethQuery, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (isEIP1559Compatible) {
+                let estimates;
+                try {
+                    estimates = yield fetchGasEstimates(fetchGasEstimatesUrl, clientId);
+                }
+                catch (_a) {
+                    estimates = yield fetchGasEstimatesViaEthFeeHistory(ethQuery);
+                }
+                const { suggestedMaxPriorityFeePerGas, suggestedMaxFeePerGas } = estimates.medium;
+                const estimatedGasFeeTimeBounds = calculateTimeEstimate(suggestedMaxPriorityFeePerGas, suggestedMaxFeePerGas, estimates);
+                return {
+                    gasFeeEstimates: estimates,
+                    estimatedGasFeeTimeBounds,
+                    gasEstimateType: GasFeeController_1.GAS_ESTIMATE_TYPES.FEE_MARKET,
+                };
+            }
+            else if (isLegacyGasAPICompatible) {
+                const estimates = yield fetchLegacyGasPriceEstimates(fetchLegacyGasPriceEstimatesUrl, clientId);
+                return {
+                    gasFeeEstimates: estimates,
+                    estimatedGasFeeTimeBounds: {},
+                    gasEstimateType: GasFeeController_1.GAS_ESTIMATE_TYPES.LEGACY,
+                };
+            }
+            throw new Error('Main gas fee/price estimation failed. Use fallback');
+        }
+        catch (_b) {
+            try {
+                const estimates = yield fetchEthGasPriceEstimate(ethQuery);
+                return {
+                    gasFeeEstimates: estimates,
+                    estimatedGasFeeTimeBounds: {},
+                    gasEstimateType: GasFeeController_1.GAS_ESTIMATE_TYPES.ETH_GASPRICE,
+                };
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Gas fee/price estimation failed. Message: ${error.message}`);
+                }
+                throw error;
+            }
+        }
+    });
+}
+exports.default = determineGasFeeCalculations;
+//# sourceMappingURL=determineGasFeeCalculations.js.map

package/dist/determineGasFeeCalculations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"determineGasFeeCalculations.js","sourceRoot":"","sources":["../src/determineGasFeeCalculations.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,yDAO4B;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAA8B,2BAA2B,CAAC,EACxD,mBAAmB,EACnB,wBAAwB,EACxB,iBAAiB,EACjB,oBAAoB,EACpB,iCAAiC,EACjC,4BAA4B,EAC5B,+BAA+B,EAC/B,wBAAwB,EACxB,qBAAqB,EACrB,QAAQ,EACR,QAAQ,GAyBT;;QACC,IAAI;YACF,IAAI,mBAAmB,EAAE;gBACvB,IAAI,SAA0B,CAAC;gBAC/B,IAAI;oBACF,SAAS,GAAG,MAAM,iBAAiB,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;iBACrE;gBAAC,WAAM;oBACN,SAAS,GAAG,MAAM,iCAAiC,CAAC,QAAQ,CAAC,CAAC;iBAC/D;gBACD,MAAM,EAAE,6BAA6B,EAAE,qBAAqB,EAAE,GAC5D,SAAS,CAAC,MAAM,CAAC;gBACnB,MAAM,yBAAyB,GAAG,qBAAqB,CACrD,6BAA6B,EAC7B,qBAAqB,EACrB,SAAS,CACV,CAAC;gBACF,OAAO;oBACL,eAAe,EAAE,SAAS;oBAC1B,yBAAyB;oBACzB,eAAe,EAAE,qCAAkB,CAAC,UAAU;iBAC/C,CAAC;aACH;iBAAM,IAAI,wBAAwB,EAAE;gBACnC,MAAM,SAAS,GAAG,MAAM,4BAA4B,CAClD,+BAA+B,EAC/B,QAAQ,CACT,CAAC;gBACF,OAAO;oBACL,eAAe,EAAE,SAAS;oBAC1B,yBAAyB,EAAE,EAAE;oBAC7B,eAAe,EAAE,qCAAkB,CAAC,MAAM;iBAC3C,CAAC;aACH;YACD,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;SACvE;QAAC,WAAM;YACN,IAAI;gBACF,MAAM,SAAS,GAAG,MAAM,wBAAwB,CAAC,QAAQ,CAAC,CAAC;gBAC3D,OAAO;oBACL,eAAe,EAAE,SAAS;oBAC1B,yBAAyB,EAAE,EAAE;oBAC7B,eAAe,EAAE,qCAAkB,CAAC,YAAY;iBACjD,CAAC;aACH;YAAC,OAAO,KAAK,EAAE;gBACd,IAAI,KAAK,YAAY,KAAK,EAAE;oBAC1B,MAAM,IAAI,KAAK,CACb,6CAA6C,KAAK,CAAC,OAAO,EAAE,CAC7D,CAAC;iBACH;gBACD,MAAM,KAAK,CAAC;aACb;SACF;IACH,CAAC;CAAA;AAtFD,8CAsFC","sourcesContent":["import {\n  GAS_ESTIMATE_TYPES,\n  EstimatedGasFeeTimeBounds,\n  EthGasPriceEstimate,\n  GasFeeEstimates,\n  GasFeeState as GasFeeCalculations,\n  LegacyGasPriceEstimate,\n} from './GasFeeController';\n\n/**\n * Obtains a set of max base and priority fee estimates along with time estimates so that we\n * can present them to users when they are sending transactions or making swaps.\n *\n * @param args - The arguments.\n * @param args.isEIP1559Compatible - Governs whether or not we can use an EIP-1559-only method to\n * produce estimates.\n * @param args.isLegacyGasAPICompatible - Governs whether or not we can use a non-EIP-1559 method to\n * produce estimates (for instance, testnets do not support estimates altogether).\n * @param args.fetchGasEstimates - A function that fetches gas estimates using an EIP-1559-specific\n * API.\n * @param args.fetchGasEstimatesUrl - The URL for the API we can use to obtain EIP-1559-specific\n * estimates.\n * @param args.fetchGasEstimatesViaEthFeeHistory - A function that fetches gas estimates using\n * `eth_feeHistory` (an EIP-1559 feature).\n * @param args.fetchLegacyGasPriceEstimates - A function that fetches gas estimates using an\n * non-EIP-1559-specific API.\n * @param args.fetchLegacyGasPriceEstimatesUrl - The URL for the API we can use to obtain\n * non-EIP-1559-specific estimates.\n * @param args.fetchEthGasPriceEstimate - A function that fetches gas estimates using\n * `eth_gasPrice`.\n * @param args.calculateTimeEstimate - A function that determine time estimate bounds.\n * @param args.clientId - An identifier that an API can use to know who is asking for estimates.\n * @param args.ethQuery - An EthQuery instance we can use to talk to Ethereum directly.\n * @returns The gas fee calculations.\n */\nexport default async function determineGasFeeCalculations({\n  isEIP1559Compatible,\n  isLegacyGasAPICompatible,\n  fetchGasEstimates,\n  fetchGasEstimatesUrl,\n  fetchGasEstimatesViaEthFeeHistory,\n  fetchLegacyGasPriceEstimates,\n  fetchLegacyGasPriceEstimatesUrl,\n  fetchEthGasPriceEstimate,\n  calculateTimeEstimate,\n  clientId,\n  ethQuery,\n}: {\n  isEIP1559Compatible: boolean;\n  isLegacyGasAPICompatible: boolean;\n  fetchGasEstimates: (\n    url: string,\n    clientId?: string,\n  ) => Promise<GasFeeEstimates>;\n  fetchGasEstimatesUrl: string;\n  fetchGasEstimatesViaEthFeeHistory: (\n    ethQuery: any,\n  ) => Promise<GasFeeEstimates>;\n  fetchLegacyGasPriceEstimates: (\n    url: string,\n    clientId?: string,\n  ) => Promise<LegacyGasPriceEstimate>;\n  fetchLegacyGasPriceEstimatesUrl: string;\n  fetchEthGasPriceEstimate: (ethQuery: any) => Promise<EthGasPriceEstimate>;\n  calculateTimeEstimate: (\n    maxPriorityFeePerGas: string,\n    maxFeePerGas: string,\n    gasFeeEstimates: GasFeeEstimates,\n  ) => EstimatedGasFeeTimeBounds;\n  clientId: string | undefined;\n  ethQuery: any;\n}): Promise<GasFeeCalculations> {\n  try {\n    if (isEIP1559Compatible) {\n      let estimates: GasFeeEstimates;\n      try {\n        estimates = await fetchGasEstimates(fetchGasEstimatesUrl, clientId);\n      } catch {\n        estimates = await fetchGasEstimatesViaEthFeeHistory(ethQuery);\n      }\n      const { suggestedMaxPriorityFeePerGas, suggestedMaxFeePerGas } =\n        estimates.medium;\n      const estimatedGasFeeTimeBounds = calculateTimeEstimate(\n        suggestedMaxPriorityFeePerGas,\n        suggestedMaxFeePerGas,\n        estimates,\n      );\n      return {\n        gasFeeEstimates: estimates,\n        estimatedGasFeeTimeBounds,\n        gasEstimateType: GAS_ESTIMATE_TYPES.FEE_MARKET,\n      };\n    } else if (isLegacyGasAPICompatible) {\n      const estimates = await fetchLegacyGasPriceEstimates(\n        fetchLegacyGasPriceEstimatesUrl,\n        clientId,\n      );\n      return {\n        gasFeeEstimates: estimates,\n        estimatedGasFeeTimeBounds: {},\n        gasEstimateType: GAS_ESTIMATE_TYPES.LEGACY,\n      };\n    }\n    throw new Error('Main gas fee/price estimation failed. Use fallback');\n  } catch {\n    try {\n      const estimates = await fetchEthGasPriceEstimate(ethQuery);\n      return {\n        gasFeeEstimates: estimates,\n        estimatedGasFeeTimeBounds: {},\n        gasEstimateType: GAS_ESTIMATE_TYPES.ETH_GASPRICE,\n      };\n    } catch (error) {\n      if (error instanceof Error) {\n        throw new Error(\n          `Gas fee/price estimation failed. Message: ${error.message}`,\n        );\n      }\n      throw error;\n    }\n  }\n}\n"]}

package/dist/fetchBlockFeeHistory.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="bn.js" />
+import { BN } from 'ethereumjs-util';
+declare type EthQuery = any;
+/**
+ * @type EthFeeHistoryResponse
+ *
+ * Response data for `eth_feeHistory`.
+ * @property oldestBlock - The id of the oldest block (in hex format) in the range of blocks
+ * requested.
+ * @property baseFeePerGas - Base fee per gas for each block in the range of blocks requested.
+ * For go-ethereum based chains baseFeePerGas will not returned in case of empty results
+ * <github.com/ethereum/go-ethereum/blob/v1.10.16/internal/ethapi/api.go#L87>
+ * @property gasUsedRatio - A number between 0 and 1 that represents the gas used vs. gas limit for
+ * each block in the range of blocks requested.
+ * @property reward - The priority fee at the percentiles requested for each block in the range of
+ * blocks requested.
+ */
+export declare type EthFeeHistoryResponse = {
+    oldestBlock: string;
+    baseFeePerGas?: string[];
+    gasUsedRatio: number[];
+    reward?: string[][];
+};
+/**
+ * @type ExistingFeeHistoryBlock
+ *
+ * Historical data for a particular block that exists on the blockchain.
+ * @property number - The number of the block, as a BN.
+ * @property baseFeePerGas - The base fee per gas for the block in WEI, as a BN.
+ * @property gasUsedRatio - A number between 0 and 1 that represents the ratio between the gas paid
+ * for the block and its set gas limit.
+ * @property priorityFeesByPercentile - The priority fees paid for the transactions in the block
+ * that occurred at particular levels at which those transactions contributed to the overall gas
+ * used for the block, indexed by those percentiles. (See docs for {@link fetchBlockFeeHistory} for more
+ * on how this works.)
+ */
+declare type ExistingFeeHistoryBlock<Percentile extends number> = {
+    number: BN;
+    baseFeePerGas: BN;
+    gasUsedRatio: number;
+    priorityFeesByPercentile: Record<Percentile, BN>;
+};
+/**
+ * @type NextFeeHistoryBlock
+ *
+ * Historical data for a theoretical block that could exist in the future.
+ * @property number - The number of the block, as a BN.
+ * @property baseFeePerGas - The estimated base fee per gas for the block in WEI, as a BN.
+ */
+declare type NextFeeHistoryBlock = {
+    number: BN;
+    baseFeePerGas: BN;
+};
+/**
+ * @type FeeHistoryBlock
+ *
+ * Historical data for a particular block.
+ * @property number - The number of the block, as a BN.
+ * @property baseFeePerGas - The base fee per gas for the block in WEI, as a BN.
+ * @property gasUsedRatio - A number between 0 and 1 that represents the ratio between the gas paid
+ * for the block and its set gas limit.
+ * @property priorityFeesByPercentile - The priority fees paid for the transactions in the block
+ * that occurred at particular levels at which those transactions contributed to the overall gas
+ * used for the block, indexed by those percentiles. (See docs for {@link fetchBlockFeeHistory} for more
+ * on how this works.)
+ */
+export declare type FeeHistoryBlock<Percentile extends number> = ExistingFeeHistoryBlock<Percentile> | NextFeeHistoryBlock;
+/**
+ * @type ExtractPercentileFrom
+ *
+ * Extracts the percentiles that the type assigned to an array of FeeHistoryBlock has been created
+ * with. This makes use of the `infer` keyword to read the type argument.
+ */
+export declare type ExtractPercentileFrom<T> = T extends FeeHistoryBlock<infer P>[] ? P : never;
+/**
+ * Uses `eth_feeHistory` (an EIP-1559 feature) to obtain information about gas fees from a range of
+ * blocks that have occurred recently on a network.
+ *
+ * To learn more, see these resources:
+ *
+ * - <https://infura.io/docs/ethereum#operation/eth_feeHistory>
+ * - <https://github.com/zsfelfoldi/feehistory/blob/main/docs/feeHistory.md>
+ * - <https://github.com/ethereum/go-ethereum/blob/57a3fab8a75eeb9c2f4fab770b73b51b9fe672c5/eth/gasprice/feehistory.go#L180>
+ * - <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md>
+ * - <https://gas-api.metaswap.codefi.network/testFeeHistory>
+ *
+ * @param args - The arguments to this function.
+ * @param args.ethQuery - An EthQuery instance that wraps a provider for the network in question.
+ * @param args.endBlock - The desired end of the requested block range. Can be "latest" if you want
+ * to start from the latest successful block or the number of a known past block.
+ * @param args.numberOfBlocks - How many total blocks to fetch. Note that if this is more than 1024,
+ * multiple calls to `eth_feeHistory` will be made.
+ * @param args.percentiles - A set of numbers between 1 and 100 which will dictate how
+ * `priorityFeesByPercentile` in each returned block will be formed. When Ethereum runs the
+ * `eth_feeHistory` method, for each block it is considering, it will first sort all transactions by
+ * the priority fee. It will then go through each transaction and add the total amount of gas paid
+ * for that transaction to a bucket which maxes out at the total gas used for the whole block. As
+ * the bucket fills, it will cross percentages which correspond to the percentiles specified here,
+ * and the priority fees of the first transactions which cause it to reach those percentages will be
+ * recorded. Hence, `priorityFeesByPercentile` represents the priority fees of transactions at key
+ * gas used contribution levels, where earlier levels have smaller contributions and later levels
+ * have higher contributions.
+ * @param args.includeNextBlock - Whether to include an extra block that represents the next
+ * block after the latest one. Only the `baseFeePerGas` will be filled in for this block (which is
+ * estimated).
+ * @returns The list of blocks and their fee data, sorted from oldest to newest.
+ */
+export default function fetchBlockFeeHistory<Percentile extends number>({ ethQuery, numberOfBlocks: totalNumberOfBlocks, endBlock: givenEndBlock, percentiles: givenPercentiles, includeNextBlock, }: {
+    ethQuery: EthQuery;
+    numberOfBlocks: number;
+    endBlock?: 'latest' | BN;
+    percentiles?: readonly Percentile[];
+    includeNextBlock?: boolean;
+}): Promise<FeeHistoryBlock<Percentile>[]>;
+export {};

package/dist/fetchBlockFeeHistory.js

@@ -0,0 +1,202 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethereumjs_util_1 = require("ethereumjs-util");
+const controller_utils_1 = require("@metamask/controller-utils");
+const MAX_NUMBER_OF_BLOCKS_PER_ETH_FEE_HISTORY_CALL = 1024;
+/**
+ * Uses `eth_feeHistory` (an EIP-1559 feature) to obtain information about gas fees from a range of
+ * blocks that have occurred recently on a network.
+ *
+ * To learn more, see these resources:
+ *
+ * - <https://infura.io/docs/ethereum#operation/eth_feeHistory>
+ * - <https://github.com/zsfelfoldi/feehistory/blob/main/docs/feeHistory.md>
+ * - <https://github.com/ethereum/go-ethereum/blob/57a3fab8a75eeb9c2f4fab770b73b51b9fe672c5/eth/gasprice/feehistory.go#L180>
+ * - <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md>
+ * - <https://gas-api.metaswap.codefi.network/testFeeHistory>
+ *
+ * @param args - The arguments to this function.
+ * @param args.ethQuery - An EthQuery instance that wraps a provider for the network in question.
+ * @param args.endBlock - The desired end of the requested block range. Can be "latest" if you want
+ * to start from the latest successful block or the number of a known past block.
+ * @param args.numberOfBlocks - How many total blocks to fetch. Note that if this is more than 1024,
+ * multiple calls to `eth_feeHistory` will be made.
+ * @param args.percentiles - A set of numbers between 1 and 100 which will dictate how
+ * `priorityFeesByPercentile` in each returned block will be formed. When Ethereum runs the
+ * `eth_feeHistory` method, for each block it is considering, it will first sort all transactions by
+ * the priority fee. It will then go through each transaction and add the total amount of gas paid
+ * for that transaction to a bucket which maxes out at the total gas used for the whole block. As
+ * the bucket fills, it will cross percentages which correspond to the percentiles specified here,
+ * and the priority fees of the first transactions which cause it to reach those percentages will be
+ * recorded. Hence, `priorityFeesByPercentile` represents the priority fees of transactions at key
+ * gas used contribution levels, where earlier levels have smaller contributions and later levels
+ * have higher contributions.
+ * @param args.includeNextBlock - Whether to include an extra block that represents the next
+ * block after the latest one. Only the `baseFeePerGas` will be filled in for this block (which is
+ * estimated).
+ * @returns The list of blocks and their fee data, sorted from oldest to newest.
+ */
+function fetchBlockFeeHistory({ ethQuery, numberOfBlocks: totalNumberOfBlocks, endBlock: givenEndBlock = 'latest', percentiles: givenPercentiles = [], includeNextBlock = false, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const percentiles = givenPercentiles.length > 0
+            ? Array.from(new Set(givenPercentiles)).sort((a, b) => a - b)
+            : [];
+        const finalEndBlockNumber = givenEndBlock === 'latest'
+            ? (0, controller_utils_1.fromHex)(yield (0, controller_utils_1.query)(ethQuery, 'blockNumber'))
+            : givenEndBlock;
+        const requestChunkSpecifiers = determineRequestChunkSpecifiers(finalEndBlockNumber, totalNumberOfBlocks);
+        const blockChunks = yield Promise.all(requestChunkSpecifiers.map(({ numberOfBlocks, endBlockNumber }, i) => {
+            return i === requestChunkSpecifiers.length - 1
+                ? makeRequestForChunk({
+                    ethQuery,
+                    numberOfBlocks,
+                    endBlockNumber,
+                    percentiles,
+                    includeNextBlock,
+                })
+                : makeRequestForChunk({
+                    ethQuery,
+                    numberOfBlocks,
+                    endBlockNumber,
+                    percentiles,
+                    includeNextBlock: false,
+                });
+        }));
+        return blockChunks.reduce((array, blocks) => [...array, ...blocks], []);
+    });
+}
+exports.default = fetchBlockFeeHistory;
+/**
+ * Builds an ExistingFeeHistoryBlock.
+ *
+ * @param args - The args to this function.
+ * @param args.number - The number of the block.
+ * @param args.baseFeePerGas - The base fee per gas of the block.
+ * @param args.blockIndex - The index of the block in the source chunk.
+ * @param args.gasUsedRatios - The gas used ratios for the block.
+ * @param args.priorityFeePercentileGroups - The priority fee percentile groups for the block.
+ * @param args.percentiles - The percentiles used to fetch the source chunk.
+ * @returns The ExistingFeeHistoryBlock.
+ */
+function buildExistingFeeHistoryBlock({ baseFeePerGas, number, blockIndex, gasUsedRatios, priorityFeePercentileGroups, percentiles, }) {
+    const gasUsedRatio = gasUsedRatios[blockIndex];
+    const priorityFeesForEachPercentile = priorityFeePercentileGroups[blockIndex];
+    const priorityFeesByPercentile = percentiles.reduce((obj, percentile, percentileIndex) => {
+        const priorityFee = priorityFeesForEachPercentile[percentileIndex];
+        return Object.assign(Object.assign({}, obj), { [percentile]: (0, controller_utils_1.fromHex)(priorityFee) });
+    }, {});
+    return {
+        number,
+        baseFeePerGas,
+        gasUsedRatio,
+        priorityFeesByPercentile,
+    };
+}
+/**
+ * Builds a NextFeeHistoryBlock.
+ *
+ * @param args - The args to this function.
+ * @param args.baseFeePerGas - The base fee per gas of the block.
+ * @param args.number - The number of the block.
+ * @returns The NextFeeHistoryBlock.
+ */
+function buildNextFeeHistoryBlock({ baseFeePerGas, number, }) {
+    return {
+        number,
+        baseFeePerGas,
+        gasUsedRatio: null,
+        priorityFeesByPercentile: null,
+    };
+}
+/**
+ * Uses eth_feeHistory to request historical data about a group of blocks (max size 1024).
+ *
+ * @param args - The arguments
+ * @param args.ethQuery - An EthQuery instance.
+ * @param args.numberOfBlocks - The number of blocks in the chunk. Must be at most 1024, as this is
+ * the maximum that `eth_feeHistory` can return in one call.
+ * @param args.endBlockNumber - The end of the requested block range.
+ * @param args.percentiles - A set of numbers between 1 and 100 that will be used to pull priority
+ * fees for each block.
+ * @param args.includeNextBlock - Whether to include an extra block that represents the next
+ * block after the latest one. Only the `baseFeePerGas` will be filled in for this block (which is
+ * estimated).
+ * @returns A list of block data.
+ */
+function makeRequestForChunk({ ethQuery, numberOfBlocks, endBlockNumber, percentiles, includeNextBlock, }) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, controller_utils_1.query)(ethQuery, 'eth_feeHistory', [(0, controller_utils_1.toHex)(numberOfBlocks), (0, controller_utils_1.toHex)(endBlockNumber), percentiles]);
+        const startBlockNumber = (0, controller_utils_1.fromHex)(response.oldestBlock);
+        if (response.baseFeePerGas !== undefined &&
+            response.baseFeePerGas.length > 0 &&
+            response.gasUsedRatio.length > 0 &&
+            (response.reward === undefined || response.reward.length > 0)) {
+            // Per
+            // <https://github.com/ethereum/go-ethereum/blob/57a3fab8a75eeb9c2f4fab770b73b51b9fe672c5/eth/gasprice/feehistory.go#L191-L192>,
+            // baseFeePerGas will always include an extra item which is the calculated base fee for the
+            // next (future) block. We may or may not care about this; if we don't, chop it off.
+            const baseFeesPerGasAsHex = includeNextBlock
+                ? response.baseFeePerGas
+                : response.baseFeePerGas.slice(0, numberOfBlocks);
+            const gasUsedRatios = response.gasUsedRatio;
+            const priorityFeePercentileGroups = (_a = response.reward) !== null && _a !== void 0 ? _a : [];
+            // Chain is allowed to return fewer number of block results
+            const numberOfExistingResults = gasUsedRatios.length;
+            return baseFeesPerGasAsHex.map((baseFeePerGasAsHex, blockIndex) => {
+                const baseFeePerGas = (0, controller_utils_1.fromHex)(baseFeePerGasAsHex);
+                const number = startBlockNumber.addn(blockIndex);
+                return blockIndex >= numberOfExistingResults
+                    ? buildNextFeeHistoryBlock({ baseFeePerGas, number })
+                    : buildExistingFeeHistoryBlock({
+                        baseFeePerGas,
+                        number,
+                        blockIndex,
+                        gasUsedRatios,
+                        priorityFeePercentileGroups,
+                        percentiles,
+                    });
+            });
+        }
+        return [];
+    });
+}
+/**
+ * Divides a block range (specified by a range size and the end of the range) into chunks based on
+ * the maximum number of blocks that `eth_feeHistory` can return in a single call.
+ *
+ * If the requested totalNumberOfBlocks exceed endBlockNumber, totalNumberOfBlocks is
+ * truncated to avoid requesting chunks with negative endBlockNumber.
+ *
+ * @param endBlockNumber - The final block in the complete desired block range after all
+ * `eth_feeHistory` requests have been made.
+ * @param totalNumberOfBlocks - The total number of desired blocks after all `eth_feeHistory`
+ * requests have been made.
+ * @returns A set of arguments that can be used to make requests to `eth_feeHistory` in order to
+ * retrieve all of the requested blocks, sorted from oldest block to newest block.
+ */
+function determineRequestChunkSpecifiers(endBlockNumber, totalNumberOfBlocks) {
+    if (endBlockNumber.lt(new ethereumjs_util_1.BN(totalNumberOfBlocks))) {
+        totalNumberOfBlocks = endBlockNumber.toNumber();
+    }
+    const specifiers = [];
+    for (let chunkStartBlockNumber = endBlockNumber.subn(totalNumberOfBlocks); chunkStartBlockNumber.lt(endBlockNumber); chunkStartBlockNumber = chunkStartBlockNumber.addn(MAX_NUMBER_OF_BLOCKS_PER_ETH_FEE_HISTORY_CALL)) {
+        const distanceToEnd = endBlockNumber.sub(chunkStartBlockNumber).toNumber();
+        const numberOfBlocks = distanceToEnd < MAX_NUMBER_OF_BLOCKS_PER_ETH_FEE_HISTORY_CALL
+            ? distanceToEnd
+            : MAX_NUMBER_OF_BLOCKS_PER_ETH_FEE_HISTORY_CALL;
+        const chunkEndBlockNumber = chunkStartBlockNumber.addn(numberOfBlocks);
+        specifiers.push({ numberOfBlocks, endBlockNumber: chunkEndBlockNumber });
+    }
+    return specifiers;
+}
+//# sourceMappingURL=fetchBlockFeeHistory.js.map

package/dist/fetchBlockFeeHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchBlockFeeHistory.js","sourceRoot":"","sources":["../src/fetchBlockFeeHistory.ts"],"names":[],"mappings":"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","sourcesContent":["import { BN } from 'ethereumjs-util';\nimport { query, fromHex, toHex } from '@metamask/controller-utils';\n\ntype EthQuery = any;\n\n/**\n * @type RequestChunkSpecifier\n *\n * Arguments to `eth_feeHistory` that can be used to fetch a set of historical data.\n * @property blockCount - The number of blocks requested.\n * @property endBlockNumber - The number of the block at the end of the requested range.\n */\ntype RequestChunkSpecifier = {\n  numberOfBlocks: number;\n  endBlockNumber: BN;\n};\n\n/**\n * @type EthFeeHistoryResponse\n *\n * Response data for `eth_feeHistory`.\n * @property oldestBlock - The id of the oldest block (in hex format) in the range of blocks\n * requested.\n * @property baseFeePerGas - Base fee per gas for each block in the range of blocks requested.\n * For go-ethereum based chains baseFeePerGas will not returned in case of empty results\n * <github.com/ethereum/go-ethereum/blob/v1.10.16/internal/ethapi/api.go#L87>\n * @property gasUsedRatio - A number between 0 and 1 that represents the gas used vs. gas limit for\n * each block in the range of blocks requested.\n * @property reward - The priority fee at the percentiles requested for each block in the range of\n * blocks requested.\n */\n\nexport type EthFeeHistoryResponse = {\n  oldestBlock: string;\n  baseFeePerGas?: string[];\n  gasUsedRatio: number[];\n  reward?: string[][];\n};\n\n/**\n * @type ExistingFeeHistoryBlock\n *\n * Historical data for a particular block that exists on the blockchain.\n * @property number - The number of the block, as a BN.\n * @property baseFeePerGas - The base fee per gas for the block in WEI, as a BN.\n * @property gasUsedRatio - A number between 0 and 1 that represents the ratio between the gas paid\n * for the block and its set gas limit.\n * @property priorityFeesByPercentile - The priority fees paid for the transactions in the block\n * that occurred at particular levels at which those transactions contributed to the overall gas\n * used for the block, indexed by those percentiles. (See docs for {@link fetchBlockFeeHistory} for more\n * on how this works.)\n */\ntype ExistingFeeHistoryBlock<Percentile extends number> = {\n  number: BN;\n  baseFeePerGas: BN;\n  gasUsedRatio: number;\n  priorityFeesByPercentile: Record<Percentile, BN>;\n};\n\n/**\n * @type NextFeeHistoryBlock\n *\n * Historical data for a theoretical block that could exist in the future.\n * @property number - The number of the block, as a BN.\n * @property baseFeePerGas - The estimated base fee per gas for the block in WEI, as a BN.\n */\ntype NextFeeHistoryBlock = {\n  number: BN;\n  baseFeePerGas: BN;\n};\n\n/**\n * @type FeeHistoryBlock\n *\n * Historical data for a particular block.\n * @property number - The number of the block, as a BN.\n * @property baseFeePerGas - The base fee per gas for the block in WEI, as a BN.\n * @property gasUsedRatio - A number between 0 and 1 that represents the ratio between the gas paid\n * for the block and its set gas limit.\n * @property priorityFeesByPercentile - The priority fees paid for the transactions in the block\n * that occurred at particular levels at which those transactions contributed to the overall gas\n * used for the block, indexed by those percentiles. (See docs for {@link fetchBlockFeeHistory} for more\n * on how this works.)\n */\nexport type FeeHistoryBlock<Percentile extends number> =\n  | ExistingFeeHistoryBlock<Percentile>\n  | NextFeeHistoryBlock;\n\n/**\n * @type ExtractPercentileFrom\n *\n * Extracts the percentiles that the type assigned to an array of FeeHistoryBlock has been created\n * with. This makes use of the `infer` keyword to read the type argument.\n */\nexport type ExtractPercentileFrom<T> = T extends FeeHistoryBlock<infer P>[]\n  ? P\n  : never;\n\nconst MAX_NUMBER_OF_BLOCKS_PER_ETH_FEE_HISTORY_CALL = 1024;\n\n/**\n * Uses `eth_feeHistory` (an EIP-1559 feature) to obtain information about gas fees from a range of\n * blocks that have occurred recently on a network.\n *\n * To learn more, see these resources:\n *\n * - <https://infura.io/docs/ethereum#operation/eth_feeHistory>\n * - <https://github.com/zsfelfoldi/feehistory/blob/main/docs/feeHistory.md>\n * - <https://github.com/ethereum/go-ethereum/blob/57a3fab8a75eeb9c2f4fab770b73b51b9fe672c5/eth/gasprice/feehistory.go#L180>\n * - <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md>\n * - <https://gas-api.metaswap.codefi.network/testFeeHistory>\n *\n * @param args - The arguments to this function.\n * @param args.ethQuery - An EthQuery instance that wraps a provider for the network in question.\n * @param args.endBlock - The desired end of the requested block range. Can be \"latest\" if you want\n * to start from the latest successful block or the number of a known past block.\n * @param args.numberOfBlocks - How many total blocks to fetch. Note that if this is more than 1024,\n * multiple calls to `eth_feeHistory` will be made.\n * @param args.percentiles - A set of numbers between 1 and 100 which will dictate how\n * `priorityFeesByPercentile` in each returned block will be formed. When Ethereum runs the\n * `eth_feeHistory` method, for each block it is considering, it will first sort all transactions by\n * the priority fee. It will then go through each transaction and add the total amount of gas paid\n * for that transaction to a bucket which maxes out at the total gas used for the whole block. As\n * the bucket fills, it will cross percentages which correspond to the percentiles specified here,\n * and the priority fees of the first transactions which cause it to reach those percentages will be\n * recorded. Hence, `priorityFeesByPercentile` represents the priority fees of transactions at key\n * gas used contribution levels, where earlier levels have smaller contributions and later levels\n * have higher contributions.\n * @param args.includeNextBlock - Whether to include an extra block that represents the next\n * block after the latest one. Only the `baseFeePerGas` will be filled in for this block (which is\n * estimated).\n * @returns The list of blocks and their fee data, sorted from oldest to newest.\n */\nexport default async function fetchBlockFeeHistory<Percentile extends number>({\n  ethQuery,\n  numberOfBlocks: totalNumberOfBlocks,\n  endBlock: givenEndBlock = 'latest',\n  percentiles: givenPercentiles = [],\n  includeNextBlock = false,\n}: {\n  ethQuery: EthQuery;\n  numberOfBlocks: number;\n  endBlock?: 'latest' | BN;\n  percentiles?: readonly Percentile[];\n  includeNextBlock?: boolean;\n}): Promise<FeeHistoryBlock<Percentile>[]> {\n  const percentiles =\n    givenPercentiles.length > 0\n      ? Array.from(new Set(givenPercentiles)).sort((a, b) => a - b)\n      : [];\n\n  const finalEndBlockNumber =\n    givenEndBlock === 'latest'\n      ? fromHex(await query(ethQuery, 'blockNumber'))\n      : givenEndBlock;\n\n  const requestChunkSpecifiers = determineRequestChunkSpecifiers(\n    finalEndBlockNumber,\n    totalNumberOfBlocks,\n  );\n\n  const blockChunks = await Promise.all(\n    requestChunkSpecifiers.map(({ numberOfBlocks, endBlockNumber }, i) => {\n      return i === requestChunkSpecifiers.length - 1\n        ? makeRequestForChunk({\n            ethQuery,\n            numberOfBlocks,\n            endBlockNumber,\n            percentiles,\n            includeNextBlock,\n          })\n        : makeRequestForChunk({\n            ethQuery,\n            numberOfBlocks,\n            endBlockNumber,\n            percentiles,\n            includeNextBlock: false,\n          });\n    }),\n  );\n\n  return blockChunks.reduce(\n    (array, blocks) => [...array, ...blocks],\n    [] as FeeHistoryBlock<Percentile>[],\n  );\n}\n\n/**\n * Builds an ExistingFeeHistoryBlock.\n *\n * @param args - The args to this function.\n * @param args.number - The number of the block.\n * @param args.baseFeePerGas - The base fee per gas of the block.\n * @param args.blockIndex - The index of the block in the source chunk.\n * @param args.gasUsedRatios - The gas used ratios for the block.\n * @param args.priorityFeePercentileGroups - The priority fee percentile groups for the block.\n * @param args.percentiles - The percentiles used to fetch the source chunk.\n * @returns The ExistingFeeHistoryBlock.\n */\nfunction buildExistingFeeHistoryBlock<Percentile extends number>({\n  baseFeePerGas,\n  number,\n  blockIndex,\n  gasUsedRatios,\n  priorityFeePercentileGroups,\n  percentiles,\n}: {\n  baseFeePerGas: BN;\n  number: BN;\n  blockIndex: number;\n  gasUsedRatios: number[];\n  priorityFeePercentileGroups: string[][];\n  percentiles: readonly Percentile[];\n}): ExistingFeeHistoryBlock<Percentile> {\n  const gasUsedRatio = gasUsedRatios[blockIndex];\n  const priorityFeesForEachPercentile = priorityFeePercentileGroups[blockIndex];\n  const priorityFeesByPercentile = percentiles.reduce(\n    (obj, percentile, percentileIndex) => {\n      const priorityFee = priorityFeesForEachPercentile[percentileIndex];\n      return { ...obj, [percentile]: fromHex(priorityFee) };\n    },\n    {} as Record<Percentile, BN>,\n  );\n\n  return {\n    number,\n    baseFeePerGas,\n    gasUsedRatio,\n    priorityFeesByPercentile,\n  };\n}\n\n/**\n * Builds a NextFeeHistoryBlock.\n *\n * @param args - The args to this function.\n * @param args.baseFeePerGas - The base fee per gas of the block.\n * @param args.number - The number of the block.\n * @returns The NextFeeHistoryBlock.\n */\nfunction buildNextFeeHistoryBlock({\n  baseFeePerGas,\n  number,\n}: {\n  baseFeePerGas: BN;\n  number: BN;\n}) {\n  return {\n    number,\n    baseFeePerGas,\n    gasUsedRatio: null,\n    priorityFeesByPercentile: null,\n  };\n}\n\n/**\n * Uses eth_feeHistory to request historical data about a group of blocks (max size 1024).\n *\n * @param args - The arguments\n * @param args.ethQuery - An EthQuery instance.\n * @param args.numberOfBlocks - The number of blocks in the chunk. Must be at most 1024, as this is\n * the maximum that `eth_feeHistory` can return in one call.\n * @param args.endBlockNumber - The end of the requested block range.\n * @param args.percentiles - A set of numbers between 1 and 100 that will be used to pull priority\n * fees for each block.\n * @param args.includeNextBlock - Whether to include an extra block that represents the next\n * block after the latest one. Only the `baseFeePerGas` will be filled in for this block (which is\n * estimated).\n * @returns A list of block data.\n */\nasync function makeRequestForChunk<Percentile extends number>({\n  ethQuery,\n  numberOfBlocks,\n  endBlockNumber,\n  percentiles,\n  includeNextBlock,\n}: {\n  ethQuery: EthQuery;\n  numberOfBlocks: number;\n  endBlockNumber: BN;\n  percentiles: readonly Percentile[];\n  includeNextBlock: boolean;\n}): Promise<FeeHistoryBlock<Percentile>[]> {\n  const response: EthFeeHistoryResponse = await query(\n    ethQuery,\n    'eth_feeHistory',\n    [toHex(numberOfBlocks), toHex(endBlockNumber), percentiles],\n  );\n\n  const startBlockNumber = fromHex(response.oldestBlock);\n\n  if (\n    response.baseFeePerGas !== undefined &&\n    response.baseFeePerGas.length > 0 &&\n    response.gasUsedRatio.length > 0 &&\n    (response.reward === undefined || response.reward.length > 0)\n  ) {\n    // Per\n    // <https://github.com/ethereum/go-ethereum/blob/57a3fab8a75eeb9c2f4fab770b73b51b9fe672c5/eth/gasprice/feehistory.go#L191-L192>,\n    // baseFeePerGas will always include an extra item which is the calculated base fee for the\n    // next (future) block. We may or may not care about this; if we don't, chop it off.\n    const baseFeesPerGasAsHex = includeNextBlock\n      ? response.baseFeePerGas\n      : response.baseFeePerGas.slice(0, numberOfBlocks);\n    const gasUsedRatios = response.gasUsedRatio;\n    const priorityFeePercentileGroups = response.reward ?? [];\n    // Chain is allowed to return fewer number of block results\n    const numberOfExistingResults = gasUsedRatios.length;\n\n    return baseFeesPerGasAsHex.map((baseFeePerGasAsHex, blockIndex) => {\n      const baseFeePerGas = fromHex(baseFeePerGasAsHex);\n      const number = startBlockNumber.addn(blockIndex);\n\n      return blockIndex >= numberOfExistingResults\n        ? buildNextFeeHistoryBlock({ baseFeePerGas, number })\n        : buildExistingFeeHistoryBlock({\n            baseFeePerGas,\n            number,\n            blockIndex,\n            gasUsedRatios,\n            priorityFeePercentileGroups,\n            percentiles,\n          });\n    });\n  }\n\n  return [];\n}\n\n/**\n * Divides a block range (specified by a range size and the end of the range) into chunks based on\n * the maximum number of blocks that `eth_feeHistory` can return in a single call.\n *\n * If the requested totalNumberOfBlocks exceed endBlockNumber, totalNumberOfBlocks is\n * truncated to avoid requesting chunks with negative endBlockNumber.\n *\n * @param endBlockNumber - The final block in the complete desired block range after all\n * `eth_feeHistory` requests have been made.\n * @param totalNumberOfBlocks - The total number of desired blocks after all `eth_feeHistory`\n * requests have been made.\n * @returns A set of arguments that can be used to make requests to `eth_feeHistory` in order to\n * retrieve all of the requested blocks, sorted from oldest block to newest block.\n */\nfunction determineRequestChunkSpecifiers(\n  endBlockNumber: BN,\n  totalNumberOfBlocks: number,\n): RequestChunkSpecifier[] {\n  if (endBlockNumber.lt(new BN(totalNumberOfBlocks))) {\n    totalNumberOfBlocks = endBlockNumber.toNumber();\n  }\n\n  const specifiers = [];\n  for (\n    let chunkStartBlockNumber = endBlockNumber.subn(totalNumberOfBlocks);\n    chunkStartBlockNumber.lt(endBlockNumber);\n    chunkStartBlockNumber = chunkStartBlockNumber.addn(\n      MAX_NUMBER_OF_BLOCKS_PER_ETH_FEE_HISTORY_CALL,\n    )\n  ) {\n    const distanceToEnd = endBlockNumber.sub(chunkStartBlockNumber).toNumber();\n    const numberOfBlocks =\n      distanceToEnd < MAX_NUMBER_OF_BLOCKS_PER_ETH_FEE_HISTORY_CALL\n        ? distanceToEnd\n        : MAX_NUMBER_OF_BLOCKS_PER_ETH_FEE_HISTORY_CALL;\n    const chunkEndBlockNumber = chunkStartBlockNumber.addn(numberOfBlocks);\n    specifiers.push({ numberOfBlocks, endBlockNumber: chunkEndBlockNumber });\n  }\n  return specifiers;\n}\n"]}

package/dist/fetchGasEstimatesViaEthFeeHistory/calculateGasFeeEstimatesForPriorityLevels.d.ts

@@ -0,0 +1,16 @@
+import { GasFeeEstimates } from '../GasFeeController';
+import { FeeHistoryBlock } from '../fetchBlockFeeHistory';
+export declare type PriorityLevel = typeof PRIORITY_LEVELS[number];
+export declare type Percentile = typeof PRIORITY_LEVEL_PERCENTILES[number];
+declare const PRIORITY_LEVELS: readonly ["low", "medium", "high"];
+declare const PRIORITY_LEVEL_PERCENTILES: readonly [10, 20, 30];
+/**
+ * Calculates a set of estimates suitable for different priority levels based on the data returned
+ * by `eth_feeHistory`.
+ *
+ * @param blocks - A set of blocks populated with data for priority fee percentiles 10, 20, and 30,
+ * obtained via {@link BlockFeeHistoryDatasetFetcher}.
+ * @returns The estimates.
+ */
+export default function calculateGasFeeEstimatesForPriorityLevels(blocks: FeeHistoryBlock<Percentile>[]): Pick<GasFeeEstimates, PriorityLevel>;
+export {};

package/dist/fetchGasEstimatesViaEthFeeHistory/calculateGasFeeEstimatesForPriorityLevels.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethereumjs_util_1 = require("ethereumjs-util");
+const ethjs_unit_1 = require("ethjs-unit");
+const controller_utils_1 = require("@metamask/controller-utils");
+const medianOf_1 = __importDefault(require("./medianOf"));
+const PRIORITY_LEVELS = ['low', 'medium', 'high'];
+const PRIORITY_LEVEL_PERCENTILES = [10, 20, 30];
+const SETTINGS_BY_PRIORITY_LEVEL = {
+    low: {
+        percentile: 10,
+        baseFeePercentageMultiplier: new ethereumjs_util_1.BN(110),
+        priorityFeePercentageMultiplier: new ethereumjs_util_1.BN(94),
+        minSuggestedMaxPriorityFeePerGas: new ethereumjs_util_1.BN(1000000000),
+        estimatedWaitTimes: {
+            minWaitTimeEstimate: 15000,
+            maxWaitTimeEstimate: 30000,
+        },
+    },
+    medium: {
+        percentile: 20,
+        baseFeePercentageMultiplier: new ethereumjs_util_1.BN(120),
+        priorityFeePercentageMultiplier: new ethereumjs_util_1.BN(97),
+        minSuggestedMaxPriorityFeePerGas: new ethereumjs_util_1.BN(1500000000),
+        estimatedWaitTimes: {
+            minWaitTimeEstimate: 15000,
+            maxWaitTimeEstimate: 45000,
+        },
+    },
+    high: {
+        percentile: 30,
+        baseFeePercentageMultiplier: new ethereumjs_util_1.BN(125),
+        priorityFeePercentageMultiplier: new ethereumjs_util_1.BN(98),
+        minSuggestedMaxPriorityFeePerGas: new ethereumjs_util_1.BN(2000000000),
+        estimatedWaitTimes: {
+            minWaitTimeEstimate: 15000,
+            maxWaitTimeEstimate: 60000,
+        },
+    },
+};
+/**
+ * Calculates a set of estimates assigned to a particular priority level based on the data returned
+ * by `eth_feeHistory`.
+ *
+ * @param priorityLevel - The level of fees that dictates how soon a transaction may go through
+ * ("low", "medium", or "high").
+ * @param blocks - A set of blocks as obtained from {@link fetchBlockFeeHistory}.
+ * @returns The estimates.
+ */
+function calculateEstimatesForPriorityLevel(priorityLevel, blocks) {
+    const settings = SETTINGS_BY_PRIORITY_LEVEL[priorityLevel];
+    const latestBaseFeePerGas = blocks[blocks.length - 1].baseFeePerGas;
+    const adjustedBaseFee = latestBaseFeePerGas
+        .mul(settings.baseFeePercentageMultiplier)
+        .divn(100);
+    const priorityFees = blocks
+        .map((block) => {
+        return 'priorityFeesByPercentile' in block
+            ? block.priorityFeesByPercentile[settings.percentile]
+            : null;
+    })
+        .filter(ethereumjs_util_1.BN.isBN);
+    const medianPriorityFee = (0, medianOf_1.default)(priorityFees);
+    const adjustedPriorityFee = medianPriorityFee
+        .mul(settings.priorityFeePercentageMultiplier)
+        .divn(100);
+    const suggestedMaxPriorityFeePerGas = ethereumjs_util_1.BN.max(adjustedPriorityFee, settings.minSuggestedMaxPriorityFeePerGas);
+    const suggestedMaxFeePerGas = adjustedBaseFee.add(suggestedMaxPriorityFeePerGas);
+    return Object.assign(Object.assign({}, settings.estimatedWaitTimes), { suggestedMaxPriorityFeePerGas: (0, ethjs_unit_1.fromWei)(suggestedMaxPriorityFeePerGas, controller_utils_1.GWEI), suggestedMaxFeePerGas: (0, ethjs_unit_1.fromWei)(suggestedMaxFeePerGas, controller_utils_1.GWEI) });
+}
+/**
+ * Calculates a set of estimates suitable for different priority levels based on the data returned
+ * by `eth_feeHistory`.
+ *
+ * @param blocks - A set of blocks populated with data for priority fee percentiles 10, 20, and 30,
+ * obtained via {@link BlockFeeHistoryDatasetFetcher}.
+ * @returns The estimates.
+ */
+function calculateGasFeeEstimatesForPriorityLevels(blocks) {
+    return PRIORITY_LEVELS.reduce((obj, priorityLevel) => {
+        const gasEstimatesForPriorityLevel = calculateEstimatesForPriorityLevel(priorityLevel, blocks);
+        return Object.assign(Object.assign({}, obj), { [priorityLevel]: gasEstimatesForPriorityLevel });
+    }, {});
+}
+exports.default = calculateGasFeeEstimatesForPriorityLevels;
+//# sourceMappingURL=calculateGasFeeEstimatesForPriorityLevels.js.map

package/dist/fetchGasEstimatesViaEthFeeHistory/calculateGasFeeEstimatesForPriorityLevels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateGasFeeEstimatesForPriorityLevels.js","sourceRoot":"","sources":["../../src/fetchGasEstimatesViaEthFeeHistory/calculateGasFeeEstimatesForPriorityLevels.ts"],"names":[],"mappings":";;;;;AAAA,qDAAqC;AACrC,2CAAqC;AACrC,iEAAkD;AAGlD,0DAAkC;AAKlC,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAU,CAAC;AAC3D,MAAM,0BAA0B,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAU,CAAC;AACzD,MAAM,0BAA0B,GAAG;IACjC,GAAG,EAAE;QACH,UAAU,EAAE,EAAgB;QAC5B,2BAA2B,EAAE,IAAI,oBAAE,CAAC,GAAG,CAAC;QACxC,+BAA+B,EAAE,IAAI,oBAAE,CAAC,EAAE,CAAC;QAC3C,gCAAgC,EAAE,IAAI,oBAAE,CAAC,UAAa,CAAC;QACvD,kBAAkB,EAAE;YAClB,mBAAmB,EAAE,KAAM;YAC3B,mBAAmB,EAAE,KAAM;SAC5B;KACF;IACD,MAAM,EAAE;QACN,UAAU,EAAE,EAAgB;QAC5B,2BAA2B,EAAE,IAAI,oBAAE,CAAC,GAAG,CAAC;QACxC,+BAA+B,EAAE,IAAI,oBAAE,CAAC,EAAE,CAAC;QAC3C,gCAAgC,EAAE,IAAI,oBAAE,CAAC,UAAa,CAAC;QACvD,kBAAkB,EAAE;YAClB,mBAAmB,EAAE,KAAM;YAC3B,mBAAmB,EAAE,KAAM;SAC5B;KACF;IACD,IAAI,EAAE;QACJ,UAAU,EAAE,EAAgB;QAC5B,2BAA2B,EAAE,IAAI,oBAAE,CAAC,GAAG,CAAC;QACxC,+BAA+B,EAAE,IAAI,oBAAE,CAAC,EAAE,CAAC;QAC3C,gCAAgC,EAAE,IAAI,oBAAE,CAAC,UAAa,CAAC;QACvD,kBAAkB,EAAE;YAClB,mBAAmB,EAAE,KAAM;YAC3B,mBAAmB,EAAE,KAAM;SAC5B;KACF;CACF,CAAC;AAEF;;;;;;;;GAQG;AACH,SAAS,kCAAkC,CACzC,aAA4B,EAC5B,MAAqC;IAErC,MAAM,QAAQ,GAAG,0BAA0B,CAAC,aAAa,CAAC,CAAC;IAE3D,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC;IAEpE,MAAM,eAAe,GAAG,mBAAmB;SACxC,GAAG,CAAC,QAAQ,CAAC,2BAA2B,CAAC;SACzC,IAAI,CAAC,GAAG,CAAC,CAAC;IACb,MAAM,YAAY,GAAG,MAAM;SACxB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACb,OAAO,0BAA0B,IAAI,KAAK;YACxC,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,QAAQ,CAAC,UAAU,CAAC;YACrD,CAAC,CAAC,IAAI,CAAC;IACX,CAAC,CAAC;SACD,MAAM,CAAC,oBAAE,CAAC,IAAI,CAAC,CAAC;IACnB,MAAM,iBAAiB,GAAG,IAAA,kBAAQ,EAAC,YAAY,CAAC,CAAC;IACjD,MAAM,mBAAmB,GAAG,iBAAiB;SAC1C,GAAG,CAAC,QAAQ,CAAC,+BAA+B,CAAC;SAC7C,IAAI,CAAC,GAAG,CAAC,CAAC;IAEb,MAAM,6BAA6B,GAAG,oBAAE,CAAC,GAAG,CAC1C,mBAAmB,EACnB,QAAQ,CAAC,gCAAgC,CAC1C,CAAC;IACF,MAAM,qBAAqB,GAAG,eAAe,CAAC,GAAG,CAC/C,6BAA6B,CAC9B,CAAC;IAEF,uCACK,QAAQ,CAAC,kBAAkB,KAC9B,6BAA6B,EAAE,IAAA,oBAAO,EAAC,6BAA6B,EAAE,uBAAI,CAAC,EAC3E,qBAAqB,EAAE,IAAA,oBAAO,EAAC,qBAAqB,EAAE,uBAAI,CAAC,IAC3D;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAwB,yCAAyC,CAC/D,MAAqC;IAErC,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,aAAa,EAAE,EAAE;QACnD,MAAM,4BAA4B,GAAG,kCAAkC,CACrE,aAAa,EACb,MAAM,CACP,CAAC;QACF,uCAAY,GAAG,KAAE,CAAC,aAAa,CAAC,EAAE,4BAA4B,IAAG;IACnE,CAAC,EAAE,EAA0C,CAAC,CAAC;AACjD,CAAC;AAVD,4DAUC","sourcesContent":["import { BN } from 'ethereumjs-util';\nimport { fromWei } from 'ethjs-unit';\nimport { GWEI } from '@metamask/controller-utils';\nimport { Eip1559GasFee, GasFeeEstimates } from '../GasFeeController';\nimport { FeeHistoryBlock } from '../fetchBlockFeeHistory';\nimport medianOf from './medianOf';\n\nexport type PriorityLevel = typeof PRIORITY_LEVELS[number];\nexport type Percentile = typeof PRIORITY_LEVEL_PERCENTILES[number];\n\nconst PRIORITY_LEVELS = ['low', 'medium', 'high'] as const;\nconst PRIORITY_LEVEL_PERCENTILES = [10, 20, 30] as const;\nconst SETTINGS_BY_PRIORITY_LEVEL = {\n  low: {\n    percentile: 10 as Percentile,\n    baseFeePercentageMultiplier: new BN(110),\n    priorityFeePercentageMultiplier: new BN(94),\n    minSuggestedMaxPriorityFeePerGas: new BN(1_000_000_000),\n    estimatedWaitTimes: {\n      minWaitTimeEstimate: 15_000,\n      maxWaitTimeEstimate: 30_000,\n    },\n  },\n  medium: {\n    percentile: 20 as Percentile,\n    baseFeePercentageMultiplier: new BN(120),\n    priorityFeePercentageMultiplier: new BN(97),\n    minSuggestedMaxPriorityFeePerGas: new BN(1_500_000_000),\n    estimatedWaitTimes: {\n      minWaitTimeEstimate: 15_000,\n      maxWaitTimeEstimate: 45_000,\n    },\n  },\n  high: {\n    percentile: 30 as Percentile,\n    baseFeePercentageMultiplier: new BN(125),\n    priorityFeePercentageMultiplier: new BN(98),\n    minSuggestedMaxPriorityFeePerGas: new BN(2_000_000_000),\n    estimatedWaitTimes: {\n      minWaitTimeEstimate: 15_000,\n      maxWaitTimeEstimate: 60_000,\n    },\n  },\n};\n\n/**\n * Calculates a set of estimates assigned to a particular priority level based on the data returned\n * by `eth_feeHistory`.\n *\n * @param priorityLevel - The level of fees that dictates how soon a transaction may go through\n * (\"low\", \"medium\", or \"high\").\n * @param blocks - A set of blocks as obtained from {@link fetchBlockFeeHistory}.\n * @returns The estimates.\n */\nfunction calculateEstimatesForPriorityLevel(\n  priorityLevel: PriorityLevel,\n  blocks: FeeHistoryBlock<Percentile>[],\n): Eip1559GasFee {\n  const settings = SETTINGS_BY_PRIORITY_LEVEL[priorityLevel];\n\n  const latestBaseFeePerGas = blocks[blocks.length - 1].baseFeePerGas;\n\n  const adjustedBaseFee = latestBaseFeePerGas\n    .mul(settings.baseFeePercentageMultiplier)\n    .divn(100);\n  const priorityFees = blocks\n    .map((block) => {\n      return 'priorityFeesByPercentile' in block\n        ? block.priorityFeesByPercentile[settings.percentile]\n        : null;\n    })\n    .filter(BN.isBN);\n  const medianPriorityFee = medianOf(priorityFees);\n  const adjustedPriorityFee = medianPriorityFee\n    .mul(settings.priorityFeePercentageMultiplier)\n    .divn(100);\n\n  const suggestedMaxPriorityFeePerGas = BN.max(\n    adjustedPriorityFee,\n    settings.minSuggestedMaxPriorityFeePerGas,\n  );\n  const suggestedMaxFeePerGas = adjustedBaseFee.add(\n    suggestedMaxPriorityFeePerGas,\n  );\n\n  return {\n    ...settings.estimatedWaitTimes,\n    suggestedMaxPriorityFeePerGas: fromWei(suggestedMaxPriorityFeePerGas, GWEI),\n    suggestedMaxFeePerGas: fromWei(suggestedMaxFeePerGas, GWEI),\n  };\n}\n\n/**\n * Calculates a set of estimates suitable for different priority levels based on the data returned\n * by `eth_feeHistory`.\n *\n * @param blocks - A set of blocks populated with data for priority fee percentiles 10, 20, and 30,\n * obtained via {@link BlockFeeHistoryDatasetFetcher}.\n * @returns The estimates.\n */\nexport default function calculateGasFeeEstimatesForPriorityLevels(\n  blocks: FeeHistoryBlock<Percentile>[],\n): Pick<GasFeeEstimates, PriorityLevel> {\n  return PRIORITY_LEVELS.reduce((obj, priorityLevel) => {\n    const gasEstimatesForPriorityLevel = calculateEstimatesForPriorityLevel(\n      priorityLevel,\n      blocks,\n    );\n    return { ...obj, [priorityLevel]: gasEstimatesForPriorityLevel };\n  }, {} as Pick<GasFeeEstimates, PriorityLevel>);\n}\n"]}

package/dist/fetchGasEstimatesViaEthFeeHistory/fetchLatestBlock.d.ts

@@ -0,0 +1,10 @@
+import { EthBlock, EthQuery } from './types';
+/**
+ * Returns information about the latest completed block.
+ *
+ * @param ethQuery - An EthQuery instance
+ * @param includeFullTransactionData - Whether or not to include all data for transactions as
+ * opposed to merely hashes. False by default.
+ * @returns The block.
+ */
+export default function fetchLatestBlock(ethQuery: EthQuery, includeFullTransactionData?: boolean): Promise<EthBlock>;

package/dist/fetchGasEstimatesViaEthFeeHistory/fetchLatestBlock.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const controller_utils_1 = require("@metamask/controller-utils");
+/**
+ * Returns information about the latest completed block.
+ *
+ * @param ethQuery - An EthQuery instance
+ * @param includeFullTransactionData - Whether or not to include all data for transactions as
+ * opposed to merely hashes. False by default.
+ * @returns The block.
+ */
+function fetchLatestBlock(ethQuery, includeFullTransactionData = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const blockNumber = yield (0, controller_utils_1.query)(ethQuery, 'blockNumber');
+        const block = yield (0, controller_utils_1.query)(ethQuery, 'getBlockByNumber', [
+            blockNumber,
+            includeFullTransactionData,
+        ]);
+        return Object.assign(Object.assign({}, block), { number: (0, controller_utils_1.fromHex)(block.number), baseFeePerGas: (0, controller_utils_1.fromHex)(block.baseFeePerGas) });
+    });
+}
+exports.default = fetchLatestBlock;
+//# sourceMappingURL=fetchLatestBlock.js.map

package/dist/fetchGasEstimatesViaEthFeeHistory/fetchLatestBlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchLatestBlock.js","sourceRoot":"","sources":["../../src/fetchGasEstimatesViaEthFeeHistory/fetchLatestBlock.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,iEAA4D;AAG5D;;;;;;;GAOG;AACH,SAA8B,gBAAgB,CAC5C,QAAkB,EAClB,0BAA0B,GAAG,KAAK;;QAElC,MAAM,WAAW,GAAG,MAAM,IAAA,wBAAK,EAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QACzD,MAAM,KAAK,GAAG,MAAM,IAAA,wBAAK,EAAC,QAAQ,EAAE,kBAAkB,EAAE;YACtD,WAAW;YACX,0BAA0B;SAC3B,CAAC,CAAC;QACH,uCACK,KAAK,KACR,MAAM,EAAE,IAAA,0BAAO,EAAC,KAAK,CAAC,MAAM,CAAC,EAC7B,aAAa,EAAE,IAAA,0BAAO,EAAC,KAAK,CAAC,aAAa,CAAC,IAC3C;IACJ,CAAC;CAAA;AAdD,mCAcC","sourcesContent":["import { query, fromHex } from '@metamask/controller-utils';\nimport { EthBlock, EthQuery } from './types';\n\n/**\n * Returns information about the latest completed block.\n *\n * @param ethQuery - An EthQuery instance\n * @param includeFullTransactionData - Whether or not to include all data for transactions as\n * opposed to merely hashes. False by default.\n * @returns The block.\n */\nexport default async function fetchLatestBlock(\n  ethQuery: EthQuery,\n  includeFullTransactionData = false,\n): Promise<EthBlock> {\n  const blockNumber = await query(ethQuery, 'blockNumber');\n  const block = await query(ethQuery, 'getBlockByNumber', [\n    blockNumber,\n    includeFullTransactionData,\n  ]);\n  return {\n    ...block,\n    number: fromHex(block.number),\n    baseFeePerGas: fromHex(block.baseFeePerGas),\n  };\n}\n"]}