tx: consolidate generic tx capabilities

packages/tx/src/baseTransaction.ts

@@ -3,7 +3,6 @@ import {
   Address,
   MAX_INTEGER,
   MAX_UINT64,
-  SECP256K1_ORDER_DIV_2,
   bigIntToHex,
   bytesToBigInt,
   bytesToHex,
@@ -179,28 +178,6 @@ export abstract class BaseTransaction<T extends TransactionType>
     return errors.length === 0
   }
 
-  protected _validateYParity() {
-    const { v } = this
-    if (v !== undefined && v !== BigInt(0) && v !== BigInt(1)) {
-      const msg = this._errorMsg('The y-parity of the transaction should either be 0 or 1')
-      throw new Error(msg)
-    }
-  }
-
-  /**
-   * EIP-2: All transaction signatures whose s-value is greater than secp256k1n/2are considered invalid.
-   * Reasoning: https://ethereum.stackexchange.com/a/55728
-   */
-  protected _validateHighS() {
-    const { s } = this
-    if (this.common.gteHardfork('homestead') && s !== undefined && s > SECP256K1_ORDER_DIV_2) {
-      const msg = this._errorMsg(
-        'Invalid Signature: s-values greater than secp256k1n/2 are considered invalid'
-      )
-      throw new Error(msg)
-    }
-  }
-
   /**
    * The minimum amount of gas the tx must have (DataFee + TxFee + Creation Fee)
    */

packages/tx/src/capabilities/eip1559.ts

@@ -0,0 +1,13 @@
+import type { Transaction, TransactionType } from '../types.js'
+
+type TypedTransactionEIP1559 =
+  | Transaction[TransactionType.BlobEIP4844]
+  | Transaction[TransactionType.FeeMarketEIP1559]
+
+export function getUpfrontCost(tx: TypedTransactionEIP1559, baseFee: bigint): bigint {
+  const prio = tx.maxPriorityFeePerGas
+  const maxBase = tx.maxFeePerGas - baseFee
+  const inclusionFeePerGas = prio < maxBase ? prio : maxBase
+  const gasPrice = inclusionFeePerGas + baseFee
+  return tx.gasLimit * gasPrice + tx.value
+}

packages/tx/src/capabilities/eip2930.ts

@@ -0,0 +1,42 @@
+import { RLP } from '@ethereumjs/rlp'
+import { concatBytes, hexToBytes } from '@ethereumjs/util'
+import { keccak256 } from 'ethereum-cryptography/keccak.js'
+
+import { BaseTransaction } from '../baseTransaction.js'
+import { type TypedTransaction } from '../types.js'
+import { AccessLists } from '../util.js'
+
+import type { Transaction, TransactionType } from '../types.js'
+
+type TypedTransactionEIP2930 = Exclude<TypedTransaction, Transaction[TransactionType.Legacy]>
+
+/**
+ * The amount of gas paid for the data in this tx
+ */
+export function getDataFee(tx: TypedTransactionEIP2930): bigint {
+  if (tx['cache'].dataFee && tx['cache'].dataFee.hardfork === tx.common.hardfork()) {
+    return tx['cache'].dataFee.value
+  }
+
+  let cost = BaseTransaction.prototype.getDataFee.bind(tx)()
+  cost += BigInt(AccessLists.getDataFeeEIP2930(tx.accessList, tx.common))
+
+  if (Object.isFrozen(tx)) {
+    tx['cache'].dataFee = {
+      value: cost,
+      hardfork: tx.common.hardfork(),
+    }
+  }
+
+  return cost
+}
+
+export function getHashedMessageToSign(tx: TypedTransactionEIP2930): Uint8Array {
+  return keccak256(tx.getMessageToSign())
+}
+
+export function serialize(tx: TypedTransactionEIP2930): Uint8Array {
+  const base = tx.raw()
+  const txTypeBytes = hexToBytes('0x' + tx.type.toString(16).padStart(2, '0'))
+  return concatBytes(txTypeBytes, RLP.encode(base))
+}

packages/tx/src/capabilities/generic.ts

@@ -0,0 +1,85 @@
+import { SECP256K1_ORDER_DIV_2, bigIntToUnpaddedBytes, ecrecover } from '@ethereumjs/util'
+import { keccak256 } from 'ethereum-cryptography/keccak.js'
+
+import { Capability, type TypedTransaction } from '../types.js'
+
+export function isSigned(tx: TypedTransaction): boolean {
+  const { v, r, s } = tx
+  if (v === undefined || r === undefined || s === undefined) {
+    return false
+  } else {
+    return true
+  }
+}
+
+export function errorMsg(tx: TypedTransaction, msg: string) {
+  return `${msg} (${tx.errorStr()})`
+}
+
+export function hash(tx: TypedTransaction): Uint8Array {
+  if (!tx.isSigned()) {
+    const msg = errorMsg(tx, 'Cannot call hash method if transaction is not signed')
+    throw new Error(msg)
+  }
+
+  if (Object.isFrozen(tx)) {
+    if (!tx['cache'].hash) {
+      tx['cache'].hash = keccak256(tx.serialize())
+    }
+    return tx['cache'].hash
+  }
+
+  return keccak256(tx.serialize())
+}
+
+/**
+ * EIP-2: All transaction signatures whose s-value is greater than secp256k1n/2are considered invalid.
+ * Reasoning: https://ethereum.stackexchange.com/a/55728
+ */
+export function validateHighS(tx: TypedTransaction): void {
+  const { s } = tx
+  if (tx.common.gteHardfork('homestead') && s !== undefined && s > SECP256K1_ORDER_DIV_2) {
+    const msg = errorMsg(
+      tx,
+      'Invalid Signature: s-values greater than secp256k1n/2 are considered invalid'
+    )
+    throw new Error(msg)
+  }
+}
+
+export function validateYParity(tx: TypedTransaction) {
+  const { v } = tx
+  if (v !== undefined && v !== BigInt(0) && v !== BigInt(1)) {
+    const msg = errorMsg(tx, 'The y-parity of the transaction should either be 0 or 1')
+    throw new Error(msg)
+  }
+}
+
+export function getSenderPublicKey(tx: TypedTransaction): Uint8Array {
+  if (tx['cache'].senderPubKey !== undefined) {
+    return tx['cache'].senderPubKey
+  }
+
+  const msgHash = tx.getMessageToVerifySignature()
+
+  const { v, r, s } = tx
+
+  validateHighS(tx)
+
+  try {
+    const sender = ecrecover(
+      msgHash,
+      v!,
+      bigIntToUnpaddedBytes(r!),
+      bigIntToUnpaddedBytes(s!),
+      tx.supports(Capability.EIP155ReplayProtection) ? tx.common.chainId() : undefined
+    )
+    if (Object.isFrozen(tx)) {
+      tx['cache'].senderPubKey = sender
+    }
+    return sender
+  } catch (e: any) {
+    const msg = errorMsg(tx, 'Invalid Signature')
+    throw new Error(msg)
+  }
+}

packages/tx/src/eip1559Transaction.ts

@@ -6,15 +6,16 @@ import {
   bytesToBigInt,
   bytesToHex,
   concatBytes,
-  ecrecover,
   equalsBytes,
   hexToBytes,
   toBytes,
   validateNoLeadingZeroes,
 } from '@ethereumjs/util'
-import { keccak256 } from 'ethereum-cryptography/keccak.js'
 
 import { BaseTransaction } from './baseTransaction.js'
+import * as EIP1559 from './capabilities/eip1559.js'
+import * as EIP2930 from './capabilities/eip2930.js'
+import * as Generic from './capabilities/generic.js'
 import { TransactionType } from './types.js'
 import { AccessLists } from './util.js'
 
@@ -188,8 +189,8 @@ export class FeeMarketEIP1559Transaction extends BaseTransaction<TransactionType
       throw new Error(msg)
     }
 
-    this._validateYParity()
-    this._validateHighS()
+    Generic.validateYParity(this)
+    Generic.validateHighS(this)
 
     const freeze = opts?.freeze ?? true
     if (freeze) {
@@ -201,33 +202,15 @@ export class FeeMarketEIP1559Transaction extends BaseTransaction<TransactionType
    * The amount of gas paid for the data in this tx
    */
   getDataFee(): bigint {
-    if (this.cache.dataFee && this.cache.dataFee.hardfork === this.common.hardfork()) {
-      return this.cache.dataFee.value
-    }
-
-    let cost = super.getDataFee()
-    cost += BigInt(AccessLists.getDataFeeEIP2930(this.accessList, this.common))
-
-    if (Object.isFrozen(this)) {
-      this.cache.dataFee = {
-        value: cost,
-        hardfork: this.common.hardfork(),
-      }
-    }
-
-    return cost
+    return EIP2930.getDataFee(this)
   }
 
   /**
    * The up front amount that an account must have for this transaction to be valid
    * @param baseFee The base fee of the block (will be set to 0 if not provided)
    */
   getUpfrontCost(baseFee: bigint = BigInt(0)): bigint {
-    const prio = this.maxPriorityFeePerGas
-    const maxBase = this.maxFeePerGas - baseFee
-    const inclusionFeePerGas = prio < maxBase ? prio : maxBase
-    const gasPrice = inclusionFeePerGas + baseFee
-    return this.gasLimit * gasPrice + this.value
+    return EIP1559.getUpfrontCost(this, baseFee)
   }
 
   /**
@@ -271,8 +254,7 @@ export class FeeMarketEIP1559Transaction extends BaseTransaction<TransactionType
    * the RLP encoding of the values.
    */
   serialize(): Uint8Array {
-    const base = this.raw()
-    return concatBytes(TRANSACTION_TYPE_BYTES, RLP.encode(base))
+    return EIP2930.serialize(this)
   }
 
   /**
@@ -300,7 +282,7 @@ export class FeeMarketEIP1559Transaction extends BaseTransaction<TransactionType
    * serialized and doesn't need to be RLP encoded any more.
    */
   getHashedMessageToSign(): Uint8Array {
-    return keccak256(this.getMessageToSign())
+    return EIP2930.getHashedMessageToSign(this)
   }
 
   /**
@@ -310,19 +292,7 @@ export class FeeMarketEIP1559Transaction extends BaseTransaction<TransactionType
    * Use {@link FeeMarketEIP1559Transaction.getMessageToSign} to get a tx hash for the purpose of signing.
    */
   public hash(): Uint8Array {
-    if (!this.isSigned()) {
-      const msg = this._errorMsg('Cannot call hash method if transaction is not signed')
-      throw new Error(msg)
-    }
-
-    if (Object.isFrozen(this)) {
-      if (!this.cache.hash) {
-        this.cache.hash = keccak256(this.serialize())
-      }
-      return this.cache.hash
-    }
-
-    return keccak256(this.serialize())
+    return Generic.hash(this)
   }
 
   /**
@@ -336,35 +306,7 @@ export class FeeMarketEIP1559Transaction extends BaseTransaction<TransactionType
    * Returns the public key of the sender
    */
   public getSenderPublicKey(): Uint8Array {
-    if (this.cache.senderPubKey !== undefined) {
-      return this.cache.senderPubKey
-    }
-
-    if (!this.isSigned()) {
-      const msg = this._errorMsg('Cannot call this method if transaction is not signed')
-      throw new Error(msg)
-    }
-
-    const msgHash = this.getMessageToVerifySignature()
-    const { v, r, s } = this
-
-    this._validateHighS()
-
-    try {
-      const sender = ecrecover(
-        msgHash,
-        v! + BigInt(27), // Recover the 27 which was stripped from ecsign
-        bigIntToUnpaddedBytes(r!),
-        bigIntToUnpaddedBytes(s!)
-      )
-      if (Object.isFrozen(this)) {
-        this.cache.senderPubKey = sender
-      }
-      return sender
-    } catch (e: any) {
-      const msg = this._errorMsg('Invalid Signature')
-      throw new Error(msg)
-    }
+    return Generic.getSenderPublicKey(this)
   }
 
   protected _processSignature(v: bigint, r: Uint8Array, s: Uint8Array) {
@@ -421,6 +363,6 @@ export class FeeMarketEIP1559Transaction extends BaseTransaction<TransactionType
    * @hidden
    */
   protected _errorMsg(msg: string) {
-    return `${msg} (${this.errorStr()})`
+    return Generic.errorMsg(this, msg)
   }
 }