@feelyourprotocol/evm 8141.0.0

package/src/opcodes/EIP1283.ts

@@ -0,0 +1,77 @@
+import { equalsBytes } from '@feelyourprotocol/util'
+
+import type { Common } from '@feelyourprotocol/common'
+import type { RunState } from '../interpreter.ts'
+
+/**
+ * Adjusts gas usage and refunds of SStore ops per EIP-1283 (Constantinople)
+ *
+ * @param {RunState} runState
+ * @param {Uint8Array}   currentStorage
+ * @param {Uint8Array}   originalStorage
+ * @param {Uint8Array}   value
+ * @param {Common}   common
+ */
+export function updateSstoreGasEIP1283(
+  runState: RunState,
+  currentStorage: Uint8Array,
+  originalStorage: Uint8Array,
+  value: Uint8Array,
+  common: Common,
+) {
+  if (equalsBytes(currentStorage, value)) {
+    // If current value equals new value (this is a no-op), 200 gas is deducted.
+    return common.param('netSstoreNoopGas')
+  }
+  // If current value does not equal new value
+  if (equalsBytes(originalStorage, currentStorage)) {
+    // If original value equals current value (this storage slot has not been changed by the current execution context)
+    if (originalStorage.length === 0) {
+      // If original value is 0, 20000 gas is deducted.
+      return common.param('netSstoreInitGas')
+    }
+    if (value.length === 0) {
+      // If new value is 0, add 15000 gas to refund counter.
+      runState.interpreter.refundGas(
+        common.param('netSstoreClearRefundGas'),
+        'EIP-1283 -> netSstoreClearRefund',
+      )
+    }
+    // Otherwise, 5000 gas is deducted.
+    return common.param('netSstoreCleanGas')
+  }
+  // If original value does not equal current value (this storage slot is dirty), 200 gas is deducted. Apply both of the following clauses.
+  if (originalStorage.length !== 0) {
+    // If original value is not 0
+    if (currentStorage.length === 0) {
+      // If current value is 0 (also means that new value is not 0), remove 15000 gas from refund counter. We can prove that refund counter will never go below 0.
+      runState.interpreter.subRefund(
+        common.param('netSstoreClearRefundGas'),
+        'EIP-1283 -> netSstoreClearRefund',
+      )
+    } else if (value.length === 0) {
+      // If new value is 0 (also means that current value is not 0), add 15000 gas to refund counter.
+      runState.interpreter.refundGas(
+        common.param('netSstoreClearRefundGas'),
+        'EIP-1283 -> netSstoreClearRefund',
+      )
+    }
+  }
+  if (equalsBytes(originalStorage, value)) {
+    // If original value equals new value (this storage slot is reset)
+    if (originalStorage.length === 0) {
+      // If original value is 0, add 19800 gas to refund counter.
+      runState.interpreter.refundGas(
+        common.param('netSstoreResetClearRefundGas'),
+        'EIP-1283 -> netSstoreResetClearRefund',
+      )
+    } else {
+      // Otherwise, add 4800 gas to refund counter.
+      runState.interpreter.refundGas(
+        common.param('netSstoreResetRefundGas'),
+        'EIP-1283 -> netSstoreResetRefund',
+      )
+    }
+  }
+  return common.param('netSstoreDirtyGas')
+}

package/src/opcodes/EIP2200.ts

@@ -0,0 +1,87 @@
+import { equalsBytes } from '@feelyourprotocol/util'
+
+import { EVMError } from '../errors.ts'
+
+import { adjustSstoreGasEIP2929 } from './EIP2929.ts'
+import { trap } from './util.ts'
+
+import type { Common } from '@feelyourprotocol/common'
+import type { RunState } from '../interpreter.ts'
+
+/**
+ * Adjusts gas usage and refunds of SStore ops per EIP-2200 (Istanbul)
+ *
+ * @param {RunState} runState
+ * @param {Uint8Array}   currentStorage
+ * @param {Uint8Array}   originalStorage
+ * @param {Uint8Array}   value
+ * @param {Common}   common
+ */
+export function updateSstoreGasEIP2200(
+  runState: RunState,
+  currentStorage: Uint8Array,
+  originalStorage: Uint8Array,
+  value: Uint8Array,
+  key: Uint8Array,
+  common: Common,
+) {
+  // Fail if not enough gas is left
+  if (runState.interpreter.getGasLeft() <= common.param('sstoreSentryEIP2200Gas')) {
+    trap(EVMError.errorMessages.OUT_OF_GAS)
+  }
+
+  // Noop
+  if (equalsBytes(currentStorage, value)) {
+    const sstoreNoopCost = common.param('sstoreNoopEIP2200Gas')
+    return adjustSstoreGasEIP2929(runState, key, sstoreNoopCost, 'noop', common)
+  }
+  if (equalsBytes(originalStorage, currentStorage)) {
+    // Create slot
+    if (originalStorage.length === 0) {
+      return common.param('sstoreInitEIP2200Gas')
+    }
+    // Delete slot
+    if (value.length === 0) {
+      runState.interpreter.refundGas(
+        common.param('sstoreClearRefundEIP2200Gas'),
+        'EIP-2200 -> sstoreClearRefundEIP2200',
+      )
+    }
+    // Write existing slot
+    return common.param('sstoreCleanEIP2200Gas')
+  }
+  if (originalStorage.length > 0) {
+    if (currentStorage.length === 0) {
+      // Recreate slot
+      runState.interpreter.subRefund(
+        common.param('sstoreClearRefundEIP2200Gas'),
+        'EIP-2200 -> sstoreClearRefundEIP2200',
+      )
+    } else if (value.length === 0) {
+      // Delete slot
+      runState.interpreter.refundGas(
+        common.param('sstoreClearRefundEIP2200Gas'),
+        'EIP-2200 -> sstoreClearRefundEIP2200',
+      )
+    }
+  }
+  if (equalsBytes(originalStorage, value)) {
+    if (originalStorage.length === 0) {
+      // Reset to original non-existent slot
+      const sstoreInitRefund = common.param('sstoreInitRefundEIP2200Gas')
+      runState.interpreter.refundGas(
+        adjustSstoreGasEIP2929(runState, key, sstoreInitRefund, 'initRefund', common),
+        'EIP-2200 -> initRefund',
+      )
+    } else {
+      // Reset to original existing slot
+      const sstoreCleanRefund = common.param('sstoreCleanRefundEIP2200Gas')
+      runState.interpreter.refundGas(
+        BigInt(adjustSstoreGasEIP2929(runState, key, sstoreCleanRefund, 'cleanRefund', common)),
+        'EIP-2200 -> cleanRefund',
+      )
+    }
+  }
+  // Dirty update
+  return common.param('sstoreDirtyEIP2200Gas')
+}

package/src/opcodes/EIP2929.ts

@@ -0,0 +1,173 @@
+import { BIGINT_0, bytesToHex } from '@feelyourprotocol/util'
+
+import type { Common } from '@feelyourprotocol/common'
+import type { RunState } from '../interpreter.ts'
+
+/**
+ * Returns the gas cost for accessing an address WITHOUT any side effects.
+ * Use this to check if you have enough gas before committing to the access.
+ *
+ * @param {RunState} runState
+ * @param {Uint8Array} address
+ * @param {Common} common
+ * @param {Boolean} chargeGas (default: true)
+ * @param {Boolean} isSelfdestruct (default: false)
+ * @returns {bigint} The gas cost for this address access
+ */
+export function getAddressAccessCost(
+  runState: RunState,
+  address: Uint8Array,
+  common: Common,
+  chargeGas = true,
+  isSelfdestruct = false,
+): bigint {
+  if (!common.isActivatedEIP(2929)) return BIGINT_0
+
+  const isCold = !runState.interpreter.journal.isWarmedAddress(address)
+
+  if (isCold) {
+    // CREATE, CREATE2 opcodes have the address warmed for free.
+    // selfdestruct beneficiary address reads are charged an *additional* cold access
+    // if binary tree not activated
+    if (chargeGas && !common.isActivatedEIP(7864)) {
+      return common.param('coldaccountaccessGas')
+    } else if (chargeGas && common.isActivatedEIP(7864)) {
+      // If binary tree is active, then the warmstoragereadGas should still be charged
+      // This is because otherwise opcodes will have cost 0 (this is thus the base fee)
+      return common.param('warmstoragereadGas')
+    }
+  } else if (chargeGas && !isSelfdestruct) {
+    // Warm: (selfdestruct beneficiary address reads are not charged when warm)
+    return common.param('warmstoragereadGas')
+  }
+  return BIGINT_0
+}
+
+/**
+ * Warms an address (adds to EIP-2929 accessed addresses set).
+ * Call this AFTER verifying you have enough gas for the access.
+ *
+ * @param {RunState} runState
+ * @param {Uint8Array} address
+ */
+export function warmAddress(runState: RunState, address: Uint8Array): void {
+  if (!runState.interpreter.journal.isWarmedAddress(address)) {
+    runState.interpreter.journal.addWarmedAddress(address)
+  }
+}
+
+/**
+ * Adds address to BAL (Block Access List) for EIP-7928.
+ * Call this AFTER verifying you have enough gas for the access.
+ *
+ * @param {RunState} runState
+ * @param {Uint8Array} address
+ * @param {Common} common
+ */
+export function addAddressToBAL(runState: RunState, address: Uint8Array, common: Common): void {
+  if (common.isActivatedEIP(7928)) {
+    const addressHex = bytesToHex(address)
+    runState.interpreter._evm.blockLevelAccessList?.addAddress(addressHex)
+  }
+}
+
+/**
+ * Adds address to accessedAddresses set if not already included.
+ * Adjusts cost incurred for executing opcode based on whether address read
+ * is warm/cold. (EIP 2929)
+ *
+ * This is a convenience function that combines getAddressAccessCost + warmAddress.
+ * For fine-grained control (e.g., EIP-7928 BAL with OOG checks), use the
+ * individual functions instead.
+ *
+ * @param {RunState} runState
+ * @param {Uint8Array}  address
+ * @param {Common}   common
+ * @param {Boolean}  chargeGas (default: true)
+ * @param {Boolean}  isSelfdestruct (default: false)
+ */
+export function accessAddressEIP2929(
+  runState: RunState,
+  address: Uint8Array,
+  common: Common,
+  chargeGas = true,
+  isSelfdestruct = false,
+): bigint {
+  if (!common.isActivatedEIP(2929)) return BIGINT_0
+
+  const cost = getAddressAccessCost(runState, address, common, chargeGas, isSelfdestruct)
+  warmAddress(runState, address)
+  return cost
+}
+
+/**
+ * Adds (address, key) to accessedStorage tuple set if not already included.
+ * Adjusts cost incurred for executing opcode based on whether storage read
+ * is warm/cold. (EIP 2929)
+ * @param {RunState} runState
+ * @param {Uint8Array} key (to storage slot)
+ * @param {Common} common
+ */
+export function accessStorageEIP2929(
+  runState: RunState,
+  key: Uint8Array,
+  isSstore: boolean,
+  common: Common,
+  chargeGas = true,
+): bigint {
+  if (!common.isActivatedEIP(2929)) return BIGINT_0
+
+  const address = runState.interpreter.getAddress().bytes
+  const slotIsCold = !runState.interpreter.journal.isWarmedStorage(address, key)
+
+  // Cold (SLOAD and SSTORE)
+  if (slotIsCold) {
+    runState.interpreter.journal.addWarmedStorage(address, key)
+    if (chargeGas && !(common.isActivatedEIP(6800) || common.isActivatedEIP(7864))) {
+      return common.param('coldsloadGas')
+    }
+  } else if (
+    chargeGas &&
+    (!isSstore || common.isActivatedEIP(6800) || common.isActivatedEIP(7864))
+  ) {
+    return common.param('warmstoragereadGas')
+  }
+  return BIGINT_0
+}
+
+/**
+ * Adjusts cost of SSTORE_RESET_GAS or SLOAD (aka sstorenoop) (EIP-2200) downward when storage
+ * location is already warm
+ * @param  {RunState} runState
+ * @param  {Uint8Array}   key          storage slot
+ * @param  {BigInt}   defaultCost  SSTORE_RESET_GAS / SLOAD
+ * @param  {string}   costName     parameter name ('noop')
+ * @param  {Common}   common
+ * @return {BigInt}                adjusted cost
+ */
+export function adjustSstoreGasEIP2929(
+  runState: RunState,
+  key: Uint8Array,
+  defaultCost: bigint,
+  costName: string,
+  common: Common,
+): bigint {
+  if (!common.isActivatedEIP(2929)) return defaultCost
+
+  const address = runState.interpreter.getAddress().bytes
+  const warmRead = common.param('warmstoragereadGas')
+  const coldSload = common.param('coldsloadGas')
+
+  if (runState.interpreter.journal.isWarmedStorage(address, key)) {
+    switch (costName) {
+      case 'noop':
+        return warmRead
+      case 'initRefund':
+        return common.param('sstoreInitEIP2200Gas') - warmRead
+      case 'cleanRefund':
+        return common.param('sstoreResetGas') - coldSload - warmRead
+    }
+  }
+
+  return defaultCost
+}