Implement EIP-2930

packages/hardhat-core/src/internal/core/jsonrpc/types/access-list.ts

@@ -0,0 +1,14 @@
+import * as t from "io-ts";
+
+import { rpcData } from "./base-types";
+
+const rpcAccessListTuple = t.type({
+  address: rpcData,
+  storageKeys: t.array(rpcData),
+});
+
+export const rpcAccessList = t.array(rpcAccessListTuple);
+
+export type RpcAccessListTuple = t.TypeOf<typeof rpcAccessListTuple>;
+
+export type RpcAccessList = t.TypeOf<typeof rpcAccessList>;

packages/hardhat-core/src/internal/core/jsonrpc/types/input/callRequest.ts

@@ -1,10 +1,10 @@
 import * as t from "io-ts";
 
 import { optional } from "../../../../util/io-ts";
+import { rpcAccessList } from "../access-list";
 import { rpcAddress, rpcData, rpcQuantity } from "../base-types";
 
 // Type used by eth_call and eth_estimateGas
-// TODO: Update to Berlin
 export const rpcCallRequest = t.type(
   {
     from: optional(rpcAddress),
@@ -13,19 +13,9 @@ export const rpcCallRequest = t.type(
     gasPrice: optional(rpcQuantity),
     value: optional(rpcQuantity),
     data: optional(rpcData),
+    accessList: optional(rpcAccessList),
   },
   "RpcCallRequest"
 );
 
-// This type represents possibly valid inputs to rpcCallRequest.
-// TODO: It can probably be inferred by io-ts.
-export interface RpcCallRequestInput {
-  from?: string;
-  to: string;
-  gas?: string;
-  gasPrice?: string;
-  value?: string;
-  data?: string;
-}
-
 export type RpcCallRequest = t.TypeOf<typeof rpcCallRequest>;

packages/hardhat-core/src/internal/core/jsonrpc/types/input/transactionRequest.ts

@@ -1,10 +1,10 @@
 import * as t from "io-ts";
 
 import { optional } from "../../../../util/io-ts";
+import { rpcAccessList } from "../access-list";
 import { rpcAddress, rpcData, rpcQuantity } from "../base-types";
 
 // Type used by eth_sendTransaction
-// TODO: Update to Berlin
 export const rpcTransactionRequest = t.type(
   {
     from: rpcAddress,
@@ -14,6 +14,8 @@ export const rpcTransactionRequest = t.type(
     value: optional(rpcQuantity),
     nonce: optional(rpcQuantity),
     data: optional(rpcData),
+    accessList: optional(rpcAccessList),
+    chainId: optional(rpcQuantity),
   },
   "RpcTransactionRequest"
 );

packages/hardhat-core/src/internal/core/jsonrpc/types/output/receipt.ts

@@ -1,6 +1,6 @@
 import * as t from "io-ts";
 
-import { nullable } from "../../../../util/io-ts";
+import { nullable, optional } from "../../../../util/io-ts";
 import { rpcAddress, rpcData, rpcHash, rpcQuantity } from "../base-types";
 
 import { rpcLog } from "./log";
@@ -19,7 +19,10 @@ export const rpcTransactionReceipt = t.type(
     contractAddress: nullable(rpcAddress),
     logs: t.array(rpcLog, "RpcLog Array"),
     logsBloom: rpcData,
-    status: rpcQuantity,
+    // This should be just optional, but Alchemy returns null
+    status: optional(nullable(rpcQuantity)),
+    root: optional(rpcData),
+    type: optional(rpcQuantity),
   },
   "RpcTransactionReceipt"
 );

packages/hardhat-core/src/internal/core/jsonrpc/types/output/transaction.ts

@@ -31,7 +31,7 @@ export const rpcTransaction = t.type(
 
     // EIP-2929/2930 properties
     type: optional(rpcQuantity),
-    chainId: optional(rpcQuantity),
+    chainId: optional(nullable(rpcQuantity)),
     accessList: optional(rpcAccessList),
   },
   "RpcTransaction"

packages/hardhat-core/src/internal/core/providers/accounts.ts

@@ -1,4 +1,3 @@
-import { Transaction as TransactionT } from "@ethereumjs/tx";
 import { BN } from "ethereumjs-util";
 import * as t from "io-ts";
 
@@ -188,9 +187,11 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
     chainId: number,
     privateKey: Buffer
   ): Promise<Buffer> {
-    const chains = await import("@ethereumjs/common/dist/chains");
+    const { chains } = await import("@ethereumjs/common/dist/chains");
 
-    const { Transaction } = await import("@ethereumjs/tx");
+    const { AccessListEIP2930Transaction, Transaction } = await import(
+      "@ethereumjs/tx"
+    );
 
     const { default: Common } = await import("@ethereumjs/common");
 
@@ -200,18 +201,36 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
     };
 
     const common =
-      chains.chains.names[chainId] !== undefined
-        ? new Common({ chain: chainId })
+      chains.names[chainId] !== undefined
+        ? new Common({ chain: chainId, hardfork: "berlin" })
         : Common.forCustomChain(
             "mainnet",
             {
               chainId,
               networkId: chainId,
             },
-            "istanbul"
+            "berlin"
           );
 
-    const transaction = Transaction.fromTxData(txData, { common });
+    let transaction;
+    if (txData.accessList !== undefined) {
+      // we convert the access list to the type
+      // that AccessListEIP2930Transaction expects
+      const accessList = txData.accessList.map(
+        ({ address, storageKeys }) =>
+          [address, storageKeys] as [Buffer, Buffer[]]
+      );
+
+      transaction = AccessListEIP2930Transaction.fromTxData(
+        {
+          ...txData,
+          accessList,
+        },
+        { common }
+      );
+    } else {
+      transaction = Transaction.fromTxData(txData, { common });
+    }
 
     const signedTransaction = transaction.sign(privateKey);
 

packages/hardhat-core/src/internal/hardhat-network/provider/PoolState.ts

@@ -1,31 +1,32 @@
-import { Transaction } from "@ethereumjs/tx";
-import { BN, toBuffer } from "ethereumjs-util";
+import { TypedTransaction } from "@ethereumjs/tx";
+import { BN } from "ethereumjs-util";
 import {
   List as ImmutableList,
   Map as ImmutableMap,
   Record as ImmutableRecord,
 } from "immutable";
 
-import { FakeSenderTransaction } from "./transactions/FakeSenderTransaction";
 import { bnToHex } from "./utils/bnToHex";
 
 export interface OrderedTransaction {
   orderId: number;
-  data: Transaction | FakeSenderTransaction;
+  data: TypedTransaction;
 }
 
 interface ImmutableOrderedTransaction {
   orderId: number;
   fakeFrom: string | undefined;
-  data: ImmutableList<string>;
+  data: string;
+  txType: number;
 }
 
 export const makeSerializedTransaction = ImmutableRecord<
   ImmutableOrderedTransaction
 >({
   orderId: 0,
   fakeFrom: undefined,
-  data: ImmutableList(),
+  data: "",
+  txType: 0,
 });
 
 export type SerializedTransaction = ImmutableRecord<
@@ -48,7 +49,3 @@ export const makePoolState = ImmutableRecord<PoolState>({
   hashToTransaction: ImmutableMap(),
   blockGasLimit: bnToHex(new BN(9500000)),
 });
-
-export function retrieveNonce(tx: SerializedTransaction) {
-  return new BN(toBuffer(tx.get("data").get(0)));
-}

packages/hardhat-core/src/internal/hardhat-network/provider/TxPool.ts

@@ -1,5 +1,5 @@
 import Common from "@ethereumjs/common";
-import { Transaction } from "@ethereumjs/tx";
+import { TransactionFactory, TypedTransaction } from "@ethereumjs/tx";
 import { StateManager } from "@ethereumjs/vm/dist/state";
 import { Address, BN, bufferToHex, toBuffer } from "ethereumjs-util";
 import { List as ImmutableList, Record as ImmutableRecord } from "immutable";
@@ -12,10 +12,10 @@ import {
   makeSerializedTransaction,
   OrderedTransaction,
   PoolState,
-  retrieveNonce,
   SenderTransactions,
   SerializedTransaction,
 } from "./PoolState";
+import { FakeSenderAccessListEIP2930Transaction } from "./transactions/FakeSenderAccessListEIP2930Transaction";
 import { FakeSenderTransaction } from "./transactions/FakeSenderTransaction";
 import { bnToHex } from "./utils/bnToHex";
 import { reorganizeTransactionsLists } from "./utils/reorganizeTransactionsLists";
@@ -25,37 +25,47 @@ import { reorganizeTransactionsLists } from "./utils/reorganizeTransactionsLists
 export function serializeTransaction(
   tx: OrderedTransaction
 ): SerializedTransaction {
-  const fields = tx.data.raw().map((field) => bufferToHex(field));
-  const immutableFields = ImmutableList(fields);
-  const isFake = tx.data instanceof FakeSenderTransaction;
+  const rlpSerialization = bufferToHex(tx.data.serialize());
+  const isFake =
+    tx.data instanceof FakeSenderTransaction ||
+    tx.data instanceof FakeSenderAccessListEIP2930Transaction;
   return makeSerializedTransaction({
     orderId: tx.orderId,
     fakeFrom: isFake ? tx.data.getSenderAddress().toString() : undefined,
-    data: immutableFields,
+    data: rlpSerialization,
+    txType: tx.data.transactionType,
   });
 }
 
-type ArrayWithFrom<T> = T[] & { from?: string };
-
 export function deserializeTransaction(
   tx: SerializedTransaction,
   common: Common
 ): OrderedTransaction {
-  const fields: ArrayWithFrom<Buffer> = tx
-    .get("data")
-    .map((field) => toBuffer(field))
-    .toArray();
-
+  const rlpSerialization = tx.get("data");
   const fakeFrom = tx.get("fakeFrom");
+
   let data;
   if (fakeFrom !== undefined) {
-    data = FakeSenderTransaction.fromSenderAndValuesArray(
-      Address.fromString(fakeFrom),
-      fields,
-      { common }
-    );
+    const sender = Address.fromString(fakeFrom);
+    const serialization = toBuffer(rlpSerialization);
+
+    if (tx.get("txType") === 1) {
+      data = FakeSenderAccessListEIP2930Transaction.fromSenderAndRlpSerializedTx(
+        sender,
+        serialization,
+        { common }
+      );
+    } else {
+      data = FakeSenderTransaction.fromSenderAndRlpSerializedTx(
+        sender,
+        serialization,
+        { common }
+      );
+    }
   } else {
-    data = Transaction.fromValuesArray(fields, { common });
+    data = TransactionFactory.fromSerializedData(toBuffer(rlpSerialization), {
+      common,
+    });
   }
   return {
     orderId: tx.get("orderId"),
@@ -84,7 +94,7 @@ export class TxPool {
     this._deserializeTransaction = (tx) => deserializeTransaction(tx, common);
   }
 
-  public async addTransaction(tx: Transaction) {
+  public async addTransaction(tx: TypedTransaction) {
     const senderAddress = this._getSenderAddress(tx);
     const senderNonce = await this.getExecutableNonce(senderAddress);
 
@@ -157,7 +167,8 @@ export class TxPool {
       return account.nonce;
     }
 
-    const lastPendingTxNonce = retrieveNonce(lastPendingTx);
+    const lastPendingTxNonce = this._deserializeTransaction(lastPendingTx).data
+      .nonce;
     return lastPendingTxNonce.addn(1);
   }
 
@@ -246,7 +257,7 @@ export class TxPool {
     this._setQueued(newQueued);
   }
 
-  private _getSenderAddress(tx: Transaction): Address {
+  private _getSenderAddress(tx: TypedTransaction): Address {
     try {
       return tx.getSenderAddress(); // verifies signature
     } catch (e) {
@@ -286,7 +297,7 @@ export class TxPool {
     return map.set(address, accountTxs.remove(indexOfTx));
   }
 
-  private _addPendingTransaction(tx: Transaction) {
+  private _addPendingTransaction(tx: TypedTransaction) {
     const orderedTx = serializeTransaction({
       orderId: this._nextOrderId++,
       data: tx,
@@ -298,15 +309,16 @@ export class TxPool {
 
     const { newPending, newQueued } = reorganizeTransactionsLists(
       accountTransactions.push(orderedTx),
-      this._getQueuedForAddress(hexSenderAddress) ?? ImmutableList()
+      this._getQueuedForAddress(hexSenderAddress) ?? ImmutableList(),
+      (stx) => this._deserializeTransaction(stx).data.nonce
     );
 
     this._setPendingForAddress(hexSenderAddress, newPending);
     this._setQueuedForAddress(hexSenderAddress, newQueued);
     this._setTransactionByHash(bufferToHex(tx.hash()), orderedTx);
   }
 
-  private _addQueuedTransaction(tx: Transaction) {
+  private _addQueuedTransaction(tx: TypedTransaction) {
     const orderedTx = serializeTransaction({
       orderId: this._nextOrderId++,
       data: tx,
@@ -323,7 +335,7 @@ export class TxPool {
   }
 
   private async _validateTransaction(
-    tx: Transaction,
+    tx: TypedTransaction,
     senderAddress: Address,
     senderNonce: BN
   ) {
@@ -385,7 +397,7 @@ export class TxPool {
     }
   }
 
-  private _knownTransaction(tx: Transaction): boolean {
+  private _knownTransaction(tx: TypedTransaction): boolean {
     const senderAddress = tx.getSenderAddress().toString();
     return (
       this._transactionExists(tx, this._getPendingForAddress(senderAddress)) ||
@@ -394,7 +406,7 @@ export class TxPool {
   }
 
   private _transactionExists(
-    tx: Transaction,
+    tx: TypedTransaction,
     txList: SenderTransactions | undefined
   ) {
     const existingTx = txList?.find((etx) =>
@@ -403,13 +415,13 @@ export class TxPool {
     return existingTx !== undefined;
   }
 
-  private _txWithNonceExists(tx: Transaction): boolean {
+  private _txWithNonceExists(tx: TypedTransaction): boolean {
     const senderAddress = tx.getSenderAddress().toString();
     const queuedTxs: SenderTransactions =
       this._getQueuedForAddress(senderAddress) ?? ImmutableList();
 
     const queuedTx = queuedTxs.find((ftx) =>
-      retrieveNonce(ftx).eq(new BN(tx.nonce))
+      this._deserializeTransaction(ftx).data.nonce.eq(tx.nonce)
     );
     return queuedTx !== undefined;
   }