Add eth_getMaxPriorityFeePerGas RPC method (#4092)

* Add initial eth_getMaxPriorityFeePerGas RPC method implementation

* Add a first simple test setup

* Add basic chain creation framing

* Add proper createBlock mocking

* Expand on test scenarios

* Expand on test cases

* Revise parameter name in tests

---------

Co-authored-by: acolytec3 <17355484+acolytec3@users.noreply.github.com>

Author: holgerd77

packages/client/src/rpc/modules/eth.ts

@@ -330,6 +330,11 @@ export class Eth {
 
     this.chainId = callWithStackTrace(this.chainId.bind(this), this._rpcDebug)
 
+    this.getMaxPriorityFeePerGas = callWithStackTrace(
+      this.getMaxPriorityFeePerGas.bind(this),
+      this._rpcDebug,
+    )
+
     this.estimateGas = middleware(
       callWithStackTrace(this.estimateGas.bind(this), this._rpcDebug),
       1,
@@ -541,6 +546,70 @@ export class Eth {
     return bigIntToHex(chainId)
   }
 
+  /**
+   * Returns an estimate for max priority fee per gas for a tx to be included in a block.
+   * @returns The max priority fee per gas.
+   */
+  async getMaxPriorityFeePerGas() {
+    if (!this.client.config.synchronized) {
+      throw {
+        code: INTERNAL_ERROR,
+        message: `client is not aware of the current chain height yet (give sync some more time)`,
+      }
+    }
+    const latest = await this._chain.getCanonicalHeadBlock()
+    // This ends up with a forward-sorted list of blocks
+    const blocks = (await this._chain.getBlocks(latest.hash(), 10, 0, true)).reverse()
+
+    // Store per-block medians
+    const blockMedians: bigint[] = []
+
+    for (const block of blocks) {
+      // Array to collect all maxPriorityFeePerGas values
+      const priorityFees: bigint[] = []
+
+      for (const tx of block.transactions) {
+        // Only EIP-1559 transactions have maxPriorityFeePerGas
+        if (tx.supports(Capability.EIP1559FeeMarket) === true) {
+          priorityFees.push((tx as FeeMarket1559Tx).maxPriorityFeePerGas)
+        }
+      }
+
+      // Calculate median for this block
+      if (priorityFees.length > 0) {
+        priorityFees.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+        const mid = Math.floor(priorityFees.length / 2)
+        let median: bigint
+        if (priorityFees.length % 2 === 0) {
+          median = (priorityFees[mid - 1] + priorityFees[mid]) / BigInt(2)
+        } else {
+          median = priorityFees[mid]
+        }
+        blockMedians.push(median)
+      }
+    }
+
+    // Linear regression to extrapolate next median value
+    function linearRegression(y: bigint[]): number {
+      const n = y.length
+      if (n === 0) return 0
+      const x = Array.from({ length: n }, (_, i) => i)
+      const meanX = x.reduce((a, b) => a + b, 0) / n
+      const meanY = y.reduce((a, b) => a + Number(b), 0) / n
+      let num = 0,
+        den = 0
+      for (let i = 0; i < n; i++) {
+        num += (x[i] - meanX) * (Number(y[i]) - meanY)
+        den += (x[i] - meanX) ** 2
+      }
+      const a = den === 0 ? 0 : num / den
+      const b = meanY - a * meanX
+      return a * n + b // predict next (n-th) value
+    }
+    const nextMedianRegression = BigInt(Math.round(linearRegression(blockMedians)))
+    return bigIntToHex(nextMedianRegression)
+  }
+
   /**
    * Generates and returns an estimate of how much gas is necessary to allow the transaction to complete.
    * The transaction will not be added to the blockchain.

packages/client/test/rpc/eth/getMaxPriorityFeePerGas.spec.ts

@@ -0,0 +1,145 @@
+import { assert, describe, it } from 'vitest'
+
+import { createFeeMarket1559Tx, createLegacyTx } from '@ethereumjs/tx'
+import type { TypedTransaction } from '@ethereumjs/tx'
+import { hexToBigInt } from '@ethereumjs/util'
+import { createClient, createManager, getRPCClient, startRPC } from '../helpers.ts'
+
+const method = 'eth_getMaxPriorityFeePerGas'
+
+type BlocksMPF = bigint[][]
+
+interface Block {
+  transactions: TypedTransaction[]
+  hash: () => Uint8Array
+}
+/**
+ * @param blockMPF - Representing txs with the respective maxPriorityFeePerGas values
+ * @param non1559Txs - Number of non-1559 txs to add to the block
+ * @returns A block representation with the transactions and a hash
+ */
+function createBlock(blockMPF: bigint[], non1559Txs = 0): Block {
+  const transactions: TypedTransaction[] = []
+  for (const mpf of blockMPF) {
+    const tx = createFeeMarket1559Tx({
+      maxFeePerGas: mpf, // Side addition to satisfy tx creation
+      maxPriorityFeePerGas: mpf,
+    })
+    transactions.push(tx)
+  }
+  for (let i = 0; i < non1559Txs; i++) {
+    const tx = createLegacyTx({})
+    transactions.push(tx)
+  }
+
+  return {
+    transactions,
+    hash: () => new Uint8Array([1]),
+  }
+}
+
+function createChain(blocksMPF: BlocksMPF = [[]], non1559Txs = 0) {
+  if (blocksMPF.length === 0) {
+    throw new Error('call with minimum 1 block')
+  }
+
+  const blocks: Block[] = []
+
+  for (const blockMPF of blocksMPF) {
+    const block = createBlock(blockMPF, non1559Txs)
+    blocks.push(block)
+  }
+  const latest = blocks[blocks.length - 1]
+  return {
+    getCanonicalHeadBlock: () => latest,
+    getBlocks: () => blocks.reverse(), // needs to be returned in reverse order to simulate reverse flag
+  }
+}
+
+async function getSetup(blocksMPF: BlocksMPF, non1559Txs = 0) {
+  const client = await createClient({ chain: createChain(blocksMPF, non1559Txs) })
+  client.config.synchronized = true
+  const manager = createManager(client)
+  const rpcServer = startRPC(manager.getMethods())
+  const rpc = getRPCClient(rpcServer)
+  return { client, manager, rpcServer, rpc }
+}
+
+describe(method, () => {
+  it('should return 0 for a simple block with no transactions', async () => {
+    const blocksMPF = [[]]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 0n)
+  })
+
+  it('should return "100" for a simple block with one 1559 tx', async () => {
+    const blocksMPF = [[100n]]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 100n)
+  })
+
+  it('should return 0 for a simple block with one non-1559 tx', async () => {
+    const blocksMPF = [[]]
+    const { rpc } = await getSetup(blocksMPF, 1)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 0n)
+  })
+
+  it('should return "100" for two simple blocks with one 1559 tx', async () => {
+    const blocksMPF = [[100n], [100n]]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 100n)
+  })
+
+  it('should return median for two transactions', async () => {
+    const blocksMPF = [[100n, 200n]]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 150n)
+  })
+
+  it('should return median for three transactions', async () => {
+    const blocksMPF = [[100n, 200n, 300n]]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 200n)
+  })
+
+  it('should apply linear regression - clear trend', async () => {
+    const blocksMPF = [[100n], [200n]]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 300n)
+  })
+
+  it('should apply linear regression - mixed upwards trend (simple)', async () => {
+    const blocksMPF = [[100n], [200n], [150n]]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 200n)
+  })
+
+  it('should apply linear regression - mixed upwards trend', async () => {
+    const blocksMPF = [[300n], [200n], [250n], [400n], [700n], [200n]]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 457n)
+  })
+
+  it('should apply median + linear regression in more complex scenarios', async () => {
+    const blocksMPF = [
+      [300n, 10n],
+      [200n, 20n],
+      [250n, 30n],
+      [400n, 40n, 100n],
+      [700n],
+      [200n, 10n],
+    ]
+    const { rpc } = await getSetup(blocksMPF)
+    const res = await rpc.request(method, [])
+    assert.strictEqual(hexToBigInt(res.result), 366n)
+  })
+})