feat: london

src/chains/ethereum/block/src/block-params.ts

@@ -0,0 +1,20 @@
+// NOTE these params may need to be changed at each hardfork
+// they can be tracked here: https://github.com/ethereumjs/ethereumjs-vm/blob/master/packages/common/src/hardforks/
+
+import { Quantity } from "@ganache/utils";
+
+export const BlockParams = {
+  /**
+   *  Base fee per gas for blocks without a parent containing a base fee per gas.
+   */
+  INITIAL_BASE_FEE_PER_GAS: 1000000000n,
+  /**
+   * Divisor used to set a block's target gas usage.
+   */
+  ELASTICITY: 2n,
+
+  /**
+   * Divisor used to limit the amount the base fee per gas can change from one block to another.
+   */
+  BASE_FEE_MAX_CHANGE_DENOMINATOR: 8n
+};

src/chains/ethereum/block/src/block.ts

@@ -16,7 +16,7 @@ import {
   serialize
 } from "./serialize";
 import { Address } from "@ganache/ethereum-address";
-
+import { BlockParams } from "./block-params";
 export class Block {
   protected _size: number;
   protected _raw: EthereumRawBlockHeader;
@@ -64,12 +64,11 @@ export class Block {
     });
   }
 
-  toJSON(includeFullTransactions = false) {
+  toJSON(includeFullTransactions = false, common: Common) {
     const hash = this.hash();
     const txFn = this.getTxFn(includeFullTransactions);
     const hashBuffer = hash.toBuffer();
     const number = this.header.number.toBuffer();
-    const common = this._common;
     const jsonTxs = this._rawTransactions.map((raw, index) => {
       const [from, hash] = this._rawTransactionMetaData[index];
       const extra: GanacheRawExtraTx = [
@@ -156,4 +155,45 @@ export class Block {
     block._size = size;
     return block;
   }
+
+  static calcNextBaseFee(common: Common, parentBlock?: Block) {
+    if (!common.isActivatedEIP(1559)) {
+      return undefined;
+    }
+    let nextBaseFee: bigint;
+    // genesis block
+    if (parentBlock === undefined) {
+      nextBaseFee = BlockParams.INITIAL_BASE_FEE_PER_GAS;
+    } else {
+      const header = parentBlock.header;
+      const parentGasTarget =
+        header.gasLimit.toBigInt() / BlockParams.ELASTICITY;
+      const parentGasUsed = header.gasUsed.toBigInt();
+      const baseFeePerGas = header.baseFeePerGas
+        ? header.baseFeePerGas.toBigInt()
+        : BlockParams.INITIAL_BASE_FEE_PER_GAS;
+      if (parentGasTarget === parentGasUsed) {
+        nextBaseFee = baseFeePerGas;
+      } else if (parentGasUsed > parentGasTarget) {
+        const gasUsedDelta = parentGasUsed - parentGasTarget;
+        const adjustedFeeDelta =
+          (baseFeePerGas * gasUsedDelta) /
+          parentGasTarget /
+          BlockParams.BASE_FEE_MAX_CHANGE_DENOMINATOR;
+        if (adjustedFeeDelta > 1n) {
+          nextBaseFee = baseFeePerGas + adjustedFeeDelta;
+        } else {
+          nextBaseFee = baseFeePerGas + 1n;
+        }
+      } else {
+        const gasUsedDelta = parentGasTarget - parentGasUsed;
+        const adjustedFeeDelta =
+          (baseFeePerGas * gasUsedDelta) /
+          parentGasTarget /
+          BlockParams.BASE_FEE_MAX_CHANGE_DENOMINATOR;
+        nextBaseFee = baseFeePerGas - adjustedFeeDelta;
+      }
+    }
+    return Quantity.from(nextBaseFee).toBuffer();
+  }
 }

src/chains/ethereum/block/src/runtime-block.ts

@@ -45,6 +45,7 @@ export type BlockHeader = {
   extraData: Data;
   mixHash: Data;
   nonce: Data;
+  baseFeePerGas?: Quantity;
 };
 
 /**
@@ -79,7 +80,9 @@ export function makeHeader(
     extraData: Data.from(raw[12]),
     mixHash: Data.from(raw[13], 32),
     nonce: Data.from(raw[14], 8),
-    totalDifficulty: Quantity.from(totalDifficulty, false)
+    totalDifficulty: Quantity.from(totalDifficulty, false),
+    baseFeePerGas:
+      raw[15] === BUFFER_EMPTY ? undefined : Quantity.from(raw[15], false)
   };
 }
 
@@ -96,6 +99,7 @@ export class RuntimeBlock {
     gasLimit: BnExtra;
     gasUsed: BnExtra;
     timestamp: BnExtra;
+    baseFeePerGas?: BnExtra;
   };
 
   constructor(
@@ -106,7 +110,8 @@ export class RuntimeBlock {
     gasUsed: Buffer,
     timestamp: Quantity,
     difficulty: Quantity,
-    previousBlockTotalDifficulty: Quantity
+    previousBlockTotalDifficulty: Quantity,
+    baseFeePerGas?: Buffer
   ) {
     const ts = timestamp.toBuffer();
     const coinbaseBuffer = coinbase.toBuffer();
@@ -120,7 +125,9 @@ export class RuntimeBlock {
       ).toBuffer(),
       gasLimit: new BnExtra(gasLimit),
       gasUsed: new BnExtra(gasUsed),
-      timestamp: new BnExtra(ts)
+      timestamp: new BnExtra(ts),
+      baseFeePerGas:
+        baseFeePerGas === undefined ? undefined : new BnExtra(baseFeePerGas)
     };
   }
 
@@ -154,7 +161,10 @@ export class RuntimeBlock {
       header.timestamp.buf,
       extraData.toBuffer(),
       BUFFER_32_ZERO, // mixHash
-      BUFFER_8_ZERO // nonce
+      BUFFER_8_ZERO, // nonce
+      header.baseFeePerGas === undefined
+        ? BUFFER_EMPTY
+        : header.baseFeePerGas.buf
     ];
     const { totalDifficulty } = header;
     const txs: TypedDatabaseTransaction[] = [];

src/chains/ethereum/block/src/serialize.ts

@@ -25,7 +25,8 @@ export type EthereumRawBlockHeader = [
   timestamp: Buffer,
   extraData: Buffer,
   mixHash: Buffer,
-  nonce: Buffer
+  nonce: Buffer,
+  baseFeePerGas?: Buffer
 ];
 export type EthereumRawBlock = [
   rawHeader: EthereumRawBlockHeader,

src/chains/ethereum/block/tests/index.test.ts

@@ -1,6 +1,103 @@
 import assert from "assert";
-import ethereumBlock from "../";
+import { Address } from "@ganache/ethereum-address";
+import { BUFFER_ZERO, Data, Quantity } from "@ganache/utils";
+import Common from "@ethereumjs/common";
+import Wallet from "../../ethereum/src/wallet";
+import { TransactionFactory } from "@ganache/ethereum-transaction";
+import { TypedRpcTransaction } from "@ganache/ethereum-transaction";
+import Blockchain from "../../ethereum/src/blockchain";
+import { EthereumOptionsConfig } from "../../options/src/index";
 
-describe("@ganache/ethereum-block", () => {
-  it("needs tests");
+describe("@ganache/ethereum-block", async () => {
+  describe("baseFeePerGas calculations", () => {
+    let blockchain: Blockchain;
+    before(async function () {
+      this.timeout(0);
+      const privKey = `0x${"46".repeat(32)}`;
+      const privKeyData = Data.from(privKey);
+      const options = EthereumOptionsConfig.normalize({
+        wallet: {
+          accounts: [
+            { secretKey: privKey, balance: 1000000000000000000000n },
+            {
+              secretKey: `0x${"46".repeat(31)}47`,
+              balance: 1000000000000000000000n
+            }
+          ]
+        },
+        miner: {
+          blockGasLimit: "0xB749E0"
+        },
+        chain: { chainId: 1337 }
+      });
+      const wallet = new Wallet(options.wallet);
+      const [from, to] = wallet.addresses;
+      const fromAddress = new Address(from);
+      const tx: TypedRpcTransaction = {
+        type: "0x2",
+        from: from,
+        to: to,
+        maxFeePerGas: "0x344221FFF",
+        chainId: "0x539",
+        gas: "0x5208"
+      };
+
+      const common = Common.forCustomChain(
+        "mainnet",
+        {
+          name: "ganache",
+          chainId: 1337,
+          comment: "Local test network",
+          bootstrapNodes: []
+        },
+        "london"
+      );
+      blockchain = new Blockchain(options, fromAddress);
+      await blockchain.initialize(wallet.initialAccounts);
+      // to verify our calculations for the block's baseFeePerGas,
+      // we're comparing our data to geth. Geth's gasLimit changes
+      // every block, so we need to set those values here according
+      // to what geth had. We'll need to reset each time a block is
+      // mined and we'll need to mine blocks such that we have one
+      // with each of the cases: 1. gasUsed < gasTarget, 2. gasUsed >
+      // gasTarget, gasUsed = gasTarget.
+      const gethBlockData = [
+        { txCount: 286, newGasLimit: 12000271 },
+        { txCount: 290, newGasLimit: 11988553 },
+        { txCount: 10, newGasLimit: 11976847 },
+        // because we use the previous block to calculate the base fee,
+        // send/mine one more tx so we can see what the reulting base fee
+        // is from the previous block
+        { txCount: 1, newGasLimit: 11965152 }
+      ];
+
+      for (let i = 0; i < gethBlockData.length; i++) {
+        const data = gethBlockData[i];
+        options.miner.blockGasLimit = Quantity.from(data.newGasLimit);
+        blockchain.pause();
+        for (let j = 0; j < data.txCount; j++) {
+          const feeMarketTx = TransactionFactory.fromRpc(tx, common);
+          await blockchain.queueTransaction(feeMarketTx, privKeyData);
+        }
+        // mine all txs in that group before moving onto the next block
+        await blockchain.resume();
+      }
+    });
+    it("has initial baseFeePerGas of 1000000000 for genesis block", async () => {
+      const block = await blockchain.blocks.get(BUFFER_ZERO);
+      assert.strictEqual(block.header.baseFeePerGas.toNumber(), 1000000000);
+    });
+    it("calculates baseFeePerGas correctly when gasUsed is equal to gasTarget", async () => {
+      const block = await blockchain.blocks.get(Buffer.from([2]));
+      assert.strictEqual(block.header.baseFeePerGas.toNumber(), 875106911);
+    });
+    it("calculates baseFeePerGas correctly when gasUsed is above gasTarget", async () => {
+      const block = await blockchain.blocks.get(Buffer.from([3]));
+      assert.strictEqual(block.header.baseFeePerGas.toNumber(), 876853759);
+    });
+    it("calculates baseFeePerGas correctly when gasUsed is below gasTarget", async () => {
+      const block = await blockchain.blocks.get(Buffer.from([4]));
+      assert.strictEqual(block.header.baseFeePerGas.toNumber(), 771090691);
+    });
+  });
 });

src/chains/ethereum/ethereum/src/api.ts

@@ -50,6 +50,7 @@ import { parseFilterDetails, parseFilterRange } from "./helpers/filter-parsing";
 import { decode } from "@ganache/rlp";
 import { Address } from "@ganache/ethereum-address";
 import { GanacheRawBlock } from "@ganache/ethereum-block";
+import { Capacity } from "./miner/miner";
 
 // Read in the current ganache version from core's package.json
 const { version } = $INLINE_JSON("../../../../packages/ganache/package.json");
@@ -276,13 +277,21 @@ export default class EthereumApi implements Api {
       // Developers like to move the blockchain forward by thousands of blocks
       // at a time and doing this would make it way faster
       for (let i = 0; i < blocks; i++) {
-        const transactions = await blockchain.mine(-1, timestamp, true);
+        const transactions = await blockchain.mine(
+          Capacity.FillBlock,
+          timestamp,
+          true
+        );
         if (vmErrorsOnRPCResponse) {
           assertExceptionalTransactions(transactions);
         }
       }
     } else {
-      const transactions = await blockchain.mine(-1, arg as number, true);
+      const transactions = await blockchain.mine(
+        Capacity.FillBlock,
+        arg as number,
+        true
+      );
       if (vmErrorsOnRPCResponse) {
         assertExceptionalTransactions(transactions);
       }
@@ -325,7 +334,7 @@ export default class EthereumApi implements Api {
 
     // TODO: do we need to mine a block here? The changes we're making really don't make any sense at all
     // and produce an invalid trie going forward.
-    await blockchain.mine(0);
+    await blockchain.mine(Capacity.Empty);
     return true;
   }
 
@@ -860,7 +869,7 @@ export default class EthereumApi implements Api {
   @assertArgLength(1, 2)
   async eth_getBlockByNumber(number: QUANTITY | Tag, transactions = false) {
     const block = await this.#blockchain.blocks.get(number).catch(_ => null);
-    return block ? block.toJSON(transactions) : null;
+    return block ? block.toJSON(transactions, this.#blockchain.common) : null;
   }
 
   /**
@@ -1638,18 +1647,25 @@ export default class EthereumApi implements Api {
         tx.gas = defaultLimit;
       }
     }
-
-    if (tx.gasPrice.isNull()) {
+    if ("gasPrice" in tx && tx.gasPrice.isNull()) {
       tx.gasPrice = this.#options.miner.defaultGasPrice;
     }
 
+    if ("maxFeePerGas" in tx && tx.maxFeePerGas.isNull()) {
+      const block = await this.#blockchain.blocks.get("latest").catch(_ => null); // prettier-ignore
+      tx.maxFeePerGas = Quantity.from(
+        Block.calcNextBaseFee(this.#blockchain.common, block)
+      );
+    }
+
     if (isUnlockedAccount) {
       const secretKey = wallet.unlockedAccounts.get(fromString);
       return blockchain.queueTransaction(tx, secretKey);
     } else {
       return blockchain.queueTransaction(tx);
     }
   }
+
   /**
    * Signs a transaction that can be submitted to the network at a later time using `eth_sendRawTransaction`.
    *