EIP-3540: EOF - EVM Object Format v1

Author: jangko

nimbus/db/accounts_cache.nim

@@ -11,7 +11,7 @@
 import
   std/[tables, hashes, sets],
   eth/[common, rlp], eth/trie/[hexary, db, trie_defs],
-  ../constants, ../utils/utils, storage_types,
+  ../constants, ../utils/[utils, eof], storage_types,
   ../../stateless/multi_keys,
   ./distinct_tries,
   ./access_list as ac_access_list,
@@ -378,25 +378,38 @@ proc getNonce*(ac: AccountsCache, address: EthAddress): AccountNonce {.inline.}
   if acc.isNil: emptyAcc.nonce
   else: acc.account.nonce
 
-proc getCode*(ac: AccountsCache, address: EthAddress): seq[byte] =
-  let acc = ac.getAccount(address, false)
-  if acc.isNil:
+proc loadCode(acc: RefAccount, ac: AccountsCache) =
+  if CodeLoaded in acc.flags or CodeChanged in acc.flags:
     return
 
-  if CodeLoaded in acc.flags or CodeChanged in acc.flags:
-    result = acc.code
+  when defined(geth):
+    let data = ac.db.get(acc.account.codeHash.data)
   else:
-    when defined(geth):
-      let data = ac.db.get(acc.account.codeHash.data)
-    else:
-      let data = ac.db.get(contractHashKey(acc.account.codeHash).toOpenArray)
+    let data = ac.db.get(contractHashKey(acc.account.codeHash).toOpenArray)
 
-    acc.code = data
-    acc.flags.incl CodeLoaded
-    result = acc.code
+  acc.code = data
+  acc.flags.incl CodeLoaded
+
+proc getCode*(ac: AccountsCache, address: EthAddress): seq[byte] =
+  let acc = ac.getAccount(address, false)
+  if acc.isNil:
+    return
+  acc.loadCode(ac)
+  acc.code
 
 proc getCodeSize*(ac: AccountsCache, address: EthAddress): int {.inline.} =
-  ac.getCode(address).len
+  let acc = ac.getAccount(address, false)
+  if acc.isNil:
+    return
+  acc.loadCode(ac)
+  acc.code.len
+
+proc hasEOFCode*(ac: AccountsCache, address: EthAddress): bool =
+  let acc = ac.getAccount(address, false)
+  if acc.isNil:
+    return
+  acc.loadCode(ac)
+  eof.hasEOFMagic(acc.code)
 
 proc getCommittedStorage*(ac: AccountsCache, address: EthAddress, slot: UInt256): UInt256 {.inline.} =
   let acc = ac.getAccount(address, false)
@@ -728,6 +741,7 @@ proc getStorage*(db: ReadOnlyStateDB, address: EthAddress, slot: UInt256): UInt2
 proc getNonce*(db: ReadOnlyStateDB, address: EthAddress): AccountNonce {.borrow.}
 proc getCode*(db: ReadOnlyStateDB, address: EthAddress): seq[byte] {.borrow.}
 proc getCodeSize*(db: ReadOnlyStateDB, address: EthAddress): int {.borrow.}
+proc hasEOFCode*(ac: ReadOnlyStateDB, address: EthAddress): bool {.borrow.}
 proc hasCodeOrNonce*(db: ReadOnlyStateDB, address: EthAddress): bool {.borrow.}
 proc accountExists*(db: ReadOnlyStateDB, address: EthAddress): bool {.borrow.}
 proc isDeadAccount*(db: ReadOnlyStateDB, address: EthAddress): bool {.borrow.}

nimbus/evm/code_stream.nim

@@ -6,31 +6,56 @@
 # at your option. This file may not be copied, modified, or distributed except according to those terms.
 
 import
-  chronicles, strformat, strutils, sequtils, parseutils, sets, macros,
+  std/[strformat, strutils, sequtils, parseutils, sets],
+  chronicles,
   eth/common,
+  stew/[results, endians2],
+  stew/ranges/ptr_arith,
+  ../utils/eof,
   ./interpreter/op_codes
 
 logScope:
   topics = "vm code_stream"
 
 type
+  CodeView = ptr UncheckedArray[byte]
+
   CodeStream* = ref object
-    bytes*: seq[byte]
+    # pre EOF byte code
+    legacyCode*: seq[byte]
+
+    # view into legacyCode or
+    # into one of EOF code section
+    codeView: CodeView
+
+    # length of legacy code or
+    # one of EOF code section
+    codeLen: int
+
     depthProcessed: int
     invalidPositions: HashSet[int]
     pc*: int
     cached: seq[(int, Op, string)]
 
+    # EOF container
+    container*: Container
+
+    # EOF code section index
+    section: int
+
 proc `$`*(b: byte): string =
   $(b.int)
 
 proc newCodeStream*(codeBytes: seq[byte]): CodeStream =
   new(result)
-  shallowCopy(result.bytes, codeBytes)
+  shallowCopy(result.legacyCode, codeBytes)
   result.pc = 0
   result.invalidPositions = initHashSet[int]()
   result.depthProcessed = 0
   result.cached = @[]
+  result.codeLen = result.legacyCode.len
+  if result.codeLen > 0:
+    result.codeView = cast[CodeView](addr result.legacyCode[0])
 
 proc newCodeStream*(codeBytes: string): CodeStream =
   newCodeStream(codeBytes.mapIt(it.byte))
@@ -47,37 +72,56 @@ proc newCodeStreamFromUnescaped*(code: string): CodeStream =
 
 proc read*(c: var CodeStream, size: int): seq[byte] =
   # TODO: use openArray[bytes]
-  if c.pc + size - 1 < c.bytes.len:
-    result = c.bytes[c.pc .. c.pc + size - 1]
+  if c.pc + size - 1 < c.codeLen:
+    result = @(makeOpenArray(addr c.codeView[c.pc], byte, size))
     c.pc += size
   else:
     result = @[]
-    c.pc = c.bytes.len
+    c.pc = c.codeLen
 
 proc readVmWord*(c: var CodeStream, n: int): UInt256 =
   ## Reads `n` bytes from the code stream and pads
   ## the remaining bytes with zeros.
-  let result_bytes = cast[ptr array[32, byte]](addr result)
+  let resultBytes = cast[ptr array[32, byte]](addr result)
 
-  let last = min(c.pc + n, c.bytes.len)
+  let last = min(c.pc + n, c.codeLen)
   let toWrite = last - c.pc
-  for i in 0 ..< toWrite : result_bytes[i] = c.bytes[last - i - 1]
+  for i in 0 ..< toWrite : resultBytes[i] = c.codeView[last - i - 1]
   c.pc = last
 
 proc readInt16*(c: var CodeStream): int =
-  result = (c.bytes[c.pc].int shl 8) or c.bytes[c.pc+1].int
+  let x = uint16.fromBytesBE(makeOpenArray(addr c.codeView[c.pc], byte, 2))
+  result = cast[int16](x).int
   c.pc += 2
 
 proc readByte*(c: var CodeStream): byte =
-  result = c.bytes[c.pc]
+  result = c.codeView[c.pc]
   inc c.pc
 
 proc len*(c: CodeStream): int =
-  len(c.bytes)
+  if c.container.code.len > 0:
+    c.container.size
+  else:
+    c.legacyCode.len
+
+proc setSection*(c: CodeStream, sec: int) =
+  if sec < c.container.code.len:
+    c.codeLen = c.container.code[sec].len
+    if c.codeLen > 0:
+      c.codeView = cast[CodeView](addr c.container.code[sec][0])
+    c.section = sec
+
+proc parseEOF*(c: CodeStream): Result[void, EOFV1Error] =
+  result = decode(c.container, c.legacyCode)
+  if result.isOk:
+    c.setSection(0)
+
+func hasEOFCode*(c: CodeStream): bool =
+  hasEOFMagic(c.legacyCode)
 
 proc next*(c: var CodeStream): Op =
-  if c.pc != c.bytes.len:
-    result = Op(c.bytes[c.pc])
+  if c.pc != c.codeLen:
+    result = Op(c.codeView[c.pc])
     inc c.pc
   else:
     result = Stop
@@ -89,11 +133,11 @@ iterator items*(c: var CodeStream): Op =
     nextOpcode = c.next()
 
 proc `[]`*(c: CodeStream, offset: int): Op =
-  Op(c.bytes[offset])
+  Op(c.codeView[offset])
 
 proc peek*(c: var CodeStream): Op =
-  if c.pc < c.bytes.len:
-    result = Op(c.bytes[c.pc])
+  if c.pc < c.codeLen:
+    result = Op(c.codeView[c.pc])
   else:
     result = Stop
 
@@ -111,7 +155,7 @@ when false:
       cs.pc = anchorPc
 
 proc isValidOpcode*(c: CodeStream, position: int): bool =
-  if position >= len(c):
+  if position >= c.codeLen:
     return false
   if position in c.invalidPositions:
     return false
@@ -141,7 +185,12 @@ proc decompile*(original: var CodeStream): seq[(int, Op, string)] =
   if original.cached.len > 0:
     return original.cached
   result = @[]
-  var c = newCodeStream(original.bytes)
+  var c = newCodeStream(original.legacyCode)
+  if c.hasEOFCode:
+    let res = c.parseEOF
+    if res.isErr:
+      return
+
   while true:
     var op = c.next
     if op >= Push1 and op <= Push32:
@@ -165,4 +214,4 @@ proc hasSStore*(c: var CodeStream): bool =
   result = opcodes.anyIt(it[1] == Sstore)
 
 proc atEnd*(c: CodeStream): bool =
-  result = c.pc >= c.bytes.len
+  result = c.pc >= c.codeLen

nimbus/evm/computation.nim

@@ -14,7 +14,7 @@ import
   "."/[transaction_tracer, types],
   ./interpreter/[gas_meter, gas_costs, op_codes],
   ../common/[common, evmforks],
-  ../utils/utils,
+  ../utils/[utils, eof],
   chronicles, chronos,
   eth/[keys],
   sets
@@ -45,6 +45,7 @@ when defined(evmc_enabled):
 
 const
   evmc_enabled* = defined(evmc_enabled)
+  ErrLegacyCode* = "invalid code: EOF contract must not deploy legacy code"
 
 # ------------------------------------------------------------------------------
 # Helpers
@@ -293,13 +294,26 @@ proc writeContract*(c: Computation)
   if len == 0:
     return
 
-  # EIP-3541 constraint (https://eips.ethereum.org/EIPS/eip-3541).
-  if fork >= FkLondon and c.output[0] == 0xEF.byte:
-    withExtra trace, "New contract code starts with 0xEF byte, not allowed by EIP-3541"
-    # TODO: Return `EVMC_CONTRACT_VALIDATION_FAILURE` (like Silkworm).
-    c.setError("EVMC_CONTRACT_VALIDATION_FAILURE", true)
+  # Reject legacy contract deployment from EOF.
+  if c.initCodeEOF and not hasEOFMagic(c.output):
+    c.setError(ErrLegacyCode, true)
     return
 
+  # EIP-3541 constraint (https://eips.ethereum.org/EIPS/eip-3541).
+  if hasEOFByte(c.output):
+    if fork >= FkEOF:
+      var con: Container
+      let res = con.decode(c.output)
+      if res.isErr:
+        c.setError("EOF retcode parse error: " & res.error.toString, true)
+        return
+
+    elif fork >= FkLondon:
+      withExtra trace, "New contract code starts with 0xEF byte, not allowed by EIP-3541"
+      # TODO: Return `EVMC_CONTRACT_VALIDATION_FAILURE` (like Silkworm).
+      c.setError("EVMC_CONTRACT_VALIDATION_FAILURE", true)
+      return
+
   # EIP-170 constraint (https://eips.ethereum.org/EIPS/eip-3541).
   if fork >= FkSpurious and len > EIP170_MAX_CODE_SIZE:
     withExtra trace, "New contract code exceeds EIP-170 limit",

nimbus/evm/interpreter/op_handlers/oph_envinfo.nim

@@ -169,8 +169,7 @@ const
         cpt.gasCosts[CodeCopy].m_handler(cpt.memory.len, memPos, len),
         reason = "CodeCopy fee")
 
-      cpt.memory.writePaddedResult(cpt.code.bytes, memPos, copyPos, len)
-
+      cpt.memory.writePaddedResult(k.cpt.code.legacyCode, memPos, copyPos, len)
 
   gasPriceOp: Vm2OpFn = proc (k: var Vm2Ctx) =
     ## 0x3A, Get price of gas in current environment.

nimbus/evm/interpreter_dispatch.nim

@@ -14,13 +14,13 @@ const
   lowMemoryCompileTime {.used.} = lowmem > 0
 
 import
-  std/[macros, strformat],
-  pkg/[chronicles, chronos, stew/byteutils],
-  ".."/[constants, utils/utils, db/accounts_cache],
+  std/[macros, sets, strformat],
+  ".."/[constants, db/accounts_cache],
   "."/[code_stream, computation],
   "."/[message, precompiles, state, types],
-  ./async/operations,
-  ./interpreter/[op_dispatcher, gas_costs]
+  ../utils/[utils, eof],
+  ./interpreter/[op_dispatcher, gas_costs],
+  pkg/[chronicles, chronos, eth/keys, stew/byteutils]
 
 {.push raises: [].}
 
@@ -100,13 +100,22 @@ proc selectVM(c: Computation, fork: EVMFork, shouldPrepareTracer: bool)
 
       genLowMemDispatcher(fork, c.instr, desc)
 
-proc beforeExecCall(c: Computation) =
+proc beforeExecCall(c: Computation): bool {.gcsafe, raises: [ValueError].} =
   c.snapshot()
   if c.msg.kind == evmcCall:
     c.vmState.mutateStateDB:
       db.subBalance(c.msg.sender, c.msg.value)
       db.addBalance(c.msg.contractAddress, c.msg.value)
 
+  if c.fork >= FkEOF:
+    if c.code.hasEOFCode:
+      # Code was already validated, so no other errors should be possible.
+      # TODO: what should we do if there is really an error?
+      let res = c.code.parseEOF()
+      if res.isErr:
+        c.setError(res.error.toString, false)
+        return true
+
 proc afterExecCall(c: Computation) =
   ## Collect all of the accounts that *may* need to be deleted based on EIP161
   ## https://github.com/ethereum/EIPs/blob/master/EIPS/eip-161.md
@@ -137,6 +146,21 @@ proc beforeExecCreate(c: Computation): bool
     if c.fork >= FkBerlin:
       db.accessList(c.msg.contractAddress)
 
+  let isCallerEOF = c.vmState.readOnlyStateDB.hasEOFCode(c.msg.sender)
+  c.initCodeEOF = c.code.hasEOFCode
+
+  if c.fork >= FkEOF:
+    if isCallerEOF and not c.initcodeEOF:
+      # Don't allow EOF contract to run legacy initcode.
+      c.setError(ErrLegacyCode, false)
+      return true
+    elif c.initcodeEOF:
+      # If the initcode is EOF, verify it is well-formed.
+      let res = c.code.parseEOF()
+      if res.isErr:
+        c.setError("EOF initcode parse error: " & res.error.toString, false)
+        return true
+
   c.snapshot()
 
   if c.vmState.readOnlyStateDB().hasCodeOrNonce(c.msg.contractAddress):
@@ -175,7 +199,6 @@ proc beforeExec(c: Computation): bool
     {.gcsafe, raises: [ValueError].} =
   if not c.msg.isCreate:
     c.beforeExecCall()
-    false
   else:
     c.beforeExecCreate()
 
@@ -306,7 +329,7 @@ proc asyncExecCallOrCreate*(c: Computation): Future[void] {.async.} =
   defer: c.dispose()
 
   await ifNecessaryGetCode(c.vmState, c.msg.contractAddress)
-  
+
   if c.beforeExec():
     return
   c.executeOpcodes()

nimbus/evm/types.nim

@@ -99,6 +99,7 @@ type
       parent*, child*:      Computation
     pendingAsyncOperation*: Future[void]
     continuation*:          proc() {.gcsafe, raises: [CatchableError].}
+    initcodeEOF*:           bool
 
   Error* = ref object
     info*:                  string