EIP-7976 + EIP-7981: calldata floor increase and access-list data cost

kevm-pyk/src/kevm_pyk/cli.py

@@ -1007,6 +1007,8 @@ def evm_chain_args(self) -> ArgumentParser:
             'SHANGHAI',
             'CANCUN',
             'PRAGUE',
+            'OSAKA',
+            'AMSTERDAM',
         )
         modes = ('NORMAL', 'VMTESTS')
 

kevm-pyk/src/kevm_pyk/gst_to_kore.py

@@ -34,7 +34,9 @@
     'Frontier': 'FRONTIER',
     'Homestead': 'HOMESTEAD',
     'EIP150': 'TANGERINE_WHISTLE',
+    'TangerineWhistle': 'TANGERINE_WHISTLE',
     'EIP158': 'SPURIOUS_DRAGON',
+    'SpuriousDragon': 'SPURIOUS_DRAGON',
     'Byzantium': 'BYZANTIUM',
     'Constantinople': 'CONSTANTINOPLE',
     'ConstantinopleFix': 'PETERSBURG',
@@ -51,6 +53,12 @@
     'CancunToPragueAtTime15k': 'PRAGUE',
     'Osaka': 'OSAKA',
     'PragueToOsakaAtTime15k': 'OSAKA',
+    'Amsterdam': 'AMSTERDAM',
+    'BPO2ToAmsterdamAtTime15k': 'AMSTERDAM',
+    'OsakaToBPO1AtTime15k': 'OSAKA',
+    'BPO1ToBPO2AtTime15k': 'OSAKA',
+    'BPO2ToBPO3AtTime15k': 'AMSTERDAM',
+    'BPO3ToBPO4AtTime15k': 'AMSTERDAM',
 }
 
 _GST_DISCARD_KEYS: Final = frozenset(
@@ -65,6 +73,8 @@
         'hasBigInt',
         'config',
         'network',
+        'receipts',
+        'blockAccessList',
     ]
 )
 _GST_LOAD_KEYS: Final = frozenset(

kevm-pyk/src/kevm_pyk/kproj/evm-semantics/driver.md

@@ -123,7 +123,7 @@ To do so, we'll extend sort `JSON` with some EVM specific syntax, and provide a
           ~> #loadAuthorities(AUTH)
           ~> #checkCreate ACCTFROM VALUE
           ~> #create ACCTFROM #newAddr(ACCTFROM, NONCE) VALUE CODE
-          ~> #finishTx ~> #finalizeTx(false, Ctxfloor(SCHED, CODE)) ~> startTx
+          ~> #finishTx ~> #finalizeTx(false, Ctxfloor(SCHED, CODE, #accessListFloorTokens(TA))) ~> startTx
          ...
          </k>
          <schedule> SCHED </schedule>
@@ -153,7 +153,7 @@ To do so, we'll extend sort `JSON` with some EVM specific syntax, and provide a
          <touchedAccounts> _ => SetItem(MINER) </touchedAccounts>
       requires #hasValidInitCode(lengthBytes(CODE), SCHED)
        andBool #isValidTransaction(TXID, ACCTFROM)
-       andBool GLIMIT >=Int maxInt(G0(SCHED, CODE, true), Ctxfloor(SCHED, CODE))
+       andBool GLIMIT >=Int maxInt(G0(SCHED, CODE, true) +Int #accessListDataCost(SCHED, TA), Ctxfloor(SCHED, CODE, #accessListFloorTokens(TA)))
 
     rule <k> loadTx(ACCTFROM)
           => #accessAccounts ACCTFROM ACCTTO #precompiledAccountsSet(SCHED)
@@ -162,7 +162,7 @@ To do so, we'll extend sort `JSON` with some EVM specific syntax, and provide a
           ~> #loadAuthorities(AUTH)
           ~> #checkCall ACCTFROM VALUE
           ~> #call ACCTFROM ACCTTO ACCTTO VALUE VALUE DATA false
-          ~> #finishTx ~> #finalizeTx(false, Ctxfloor(SCHED, DATA)) ~> startTx
+          ~> #finishTx ~> #finalizeTx(false, Ctxfloor(SCHED, DATA, #accessListFloorTokens(TA))) ~> startTx
          ...
          </k>
          <schedule> SCHED </schedule>
@@ -194,7 +194,7 @@ To do so, we'll extend sort `JSON` with some EVM specific syntax, and provide a
          <touchedAccounts> _ => SetItem(MINER) </touchedAccounts>
       requires ACCTTO =/=K .Account
        andBool #isValidTransaction(TXID, ACCTFROM)
-       andBool GLIMIT >=Int maxInt(G0(SCHED, DATA, false), Ctxfloor(SCHED, DATA))
+       andBool GLIMIT >=Int maxInt(G0(SCHED, DATA, false) +Int #accessListDataCost(SCHED, TA), Ctxfloor(SCHED, DATA, #accessListFloorTokens(TA)))
 
     rule <k> loadTx(_) => startTx ... </k>
          <statusCode> _ => EVMC_INVALID_BLOCK </statusCode>
@@ -251,11 +251,24 @@ To do so, we'll extend sort `JSON` with some EVM specific syntax, and provide a
          ...
          </k>
          <schedule> SCHED </schedule>
-         <callGas> GLIMIT => GLIMIT -Int Gaccessliststoragekey < SCHED > </callGas>
+         <callGas> GLIMIT => GLIMIT -Int Gaccessliststoragekey < SCHED >
+                             -Int #if Ghaseip7981 << SCHED >> #then 128 *Int Gtxdatafloor < SCHED > #else 0 #fi </callGas>
 
     rule <k> #loadAccessListAux (ACCT, .List) => #accessAccounts ACCT ... </k>
          <schedule> SCHED </schedule>
-         <callGas> GLIMIT => GLIMIT -Int Gaccesslistaddress < SCHED > </callGas>
+         <callGas> GLIMIT => GLIMIT -Int Gaccesslistaddress < SCHED >
+                             -Int #if Ghaseip7981 << SCHED >> #then 80 *Int Gtxdatafloor < SCHED > #else 0 #fi </callGas>
+
+    syntax Int ::= #accessListFloorTokens ( JSON )            [symbol(#accessListFloorTokens), function, total]
+                 | #accessListDataCost    ( Schedule , JSON ) [symbol(#accessListDataCost),    function, total]
+ // -----------------------------------------------------------------------------------------------------------
+    rule #accessListFloorTokens([[_, [STRG:JSONs]], REST])
+      => 80 +Int (128 *Int size(#parseAccessListStorageKeys([STRG]))) +Int #accessListFloorTokens([REST])
+    rule #accessListFloorTokens(_) => 0 [owise]
+
+    rule #accessListDataCost(SCHED, TA) => Gtxdatafloor < SCHED > *Int #accessListFloorTokens(TA)
+      requires Ghaseip7981 << SCHED >>
+    rule #accessListDataCost(_, _) => 0 [owise]
 ```
 
 Processing SetCode Transaction Authority Entries
@@ -624,6 +637,7 @@ Here we check the other post-conditions associated with an EVM test.
                         SetItem("receiptTrie") SetItem("stateRoot") SetItem("timestamp")
                         SetItem("transactionsTrie") SetItem("uncleHash") SetItem("baseFeePerGas") SetItem("withdrawalsRoot")
                         SetItem("blobGasUsed") SetItem("excessBlobGas") SetItem("parentBeaconBlockRoot") SetItem("requestsHash")
+                        SetItem("blockAccessListHash") SetItem("slotNumber")
                       )
 
     rule <k> check "blockHeader" : { "bloom"                : VALUE } => .K ... </k> <logsBloom>        VALUE </logsBloom>
@@ -647,6 +661,8 @@ Here we check the other post-conditions associated with an EVM test.
     rule <k> check "blockHeader" : { "excessBlobGas"        : VALUE } => .K ... </k> <excessBlobGas>    VALUE </excessBlobGas>
     rule <k> check "blockHeader" : { "parentBeaconBlockRoot": VALUE } => .K ... </k> <beaconRoot>       VALUE </beaconRoot>
     rule <k> check "blockHeader" : { "requestsHash"         : VALUE } => .K ... </k> <requestsRoot>     VALUE </requestsRoot>
+    rule <k> check "blockHeader" : { "blockAccessListHash"  : VALUE } => .K ... </k> <balHash>          VALUE </balHash>
+    rule <k> check "blockHeader" : { "slotNumber"           : VALUE } => .K ... </k> <slotNumber>       VALUE </slotNumber>
 
 
     rule <k> check "blockHeader" : { "hash": HASH:Bytes } => .K ...</k>
@@ -671,11 +687,14 @@ Here we check the other post-conditions associated with an EVM test.
          <excessBlobGas>    EB </excessBlobGas>
          <beaconRoot>       BR </beaconRoot>
          <requestsRoot>     RR </requestsRoot>
-      requires #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN)                         ==Int #asWord(HASH)
-        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF)                     ==Int #asWord(HASH)
-        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR)                 ==Int #asWord(HASH)
-        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR)     ==Int #asWord(HASH)
-        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR) ==Int #asWord(HASH)
+         <balHash>          BAL </balHash>
+         <slotNumber>       SN </slotNumber>
+      requires #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN)                                  ==Int #asWord(HASH)
+        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF)                              ==Int #asWord(HASH)
+        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR)                          ==Int #asWord(HASH)
+        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR)              ==Int #asWord(HASH)
+        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR)          ==Int #asWord(HASH)
+        orBool #blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR, BAL, SN) ==Int #asWord(HASH)
 
     rule <k> check { "genesisBlockHeader" : BLOCKHEADER } => check "genesisBlockHeader" : BLOCKHEADER ... </k>
  // ---------------------------------------------------------------------------------------------------------

kevm-pyk/src/kevm_pyk/kproj/evm-semantics/evm.md

@@ -123,6 +123,8 @@ In the comments next to each cell, we've marked which component of the YellowPap
               <excessBlobGas>    0      </excessBlobGas>
               <beaconRoot>       0      </beaconRoot>
               <requestsRoot>     0      </requestsRoot>
+              <balHash>          0      </balHash>
+              <slotNumber>       0      </slotNumber>
 
               <ommerBlockHeaders> [ .JSONs ] </ommerBlockHeaders>
             </block>
@@ -2190,6 +2192,7 @@ Precompiled Contracts
     rule #precompiledAccountsUB(CANCUN)            => 10
     rule #precompiledAccountsUB(PRAGUE)            => 17
     rule #precompiledAccountsUB(OSAKA)             => #precompiledAccountsUB(PRAGUE)
+    rule #precompiledAccountsUB(AMSTERDAM)         => #precompiledAccountsUB(OSAKA)
 
 
     syntax Set ::= #precompiledAccountsSet    ( Schedule ) [symbol(#precompiledAccountsSet),    function, total]

kevm-pyk/src/kevm_pyk/kproj/evm-semantics/gas.md

@@ -126,7 +126,7 @@ module GAS-FEES
                  | Cblobfee         ( Schedule , Int , Int )                      [symbol(Cblobfee),          function, total, smtlib(gas_Cblobfee)         ]
                  | Cexcessblob      ( Schedule , Int , Int )                      [symbol(Cexcessblob),       function, total, smtlib(gas_Cexcessblob)      ]
                  | Cdelegationaccess( Schedule, Bool, Bool )                      [symbol(Cdelegationaccess), function, total, smtlib(gas_Cdelegationaccess)]
-                 | Ctxfloor         ( Schedule , Bytes )                          [symbol(Ctxfloor),          function, total, smtlib(gas_Ctxfloor)         ]
+                 | Ctxfloor         ( Schedule , Bytes , Int )                    [symbol(Ctxfloor),          function, total, smtlib(gas_Ctxfloor)         ]
  // ---------------------------------------------------------------------------------------------------------------------------------------------------------
     rule [Cgascap]:
          Cgascap(SCHED, GCAP:Int, GAVAIL:Int, GEXTRA)
@@ -284,8 +284,14 @@ module GAS-FEES
     rule #tokensInCalldata(_,  I, I, R) => R
     rule #tokensInCalldata(WS, I, J, R) => #tokensInCalldata(WS, I+Int 1, J, R +Int #if WS[I] ==Int 0 #then 1 #else 4 #fi) [owise]
 
-    rule Ctxfloor(SCHED, CODE) => Gtransaction < SCHED > +Int (Gtxdatafloor < SCHED > *Int #tokensInCalldata(CODE)) requires Ghasfloorcost << SCHED >>
-    rule Ctxfloor(    _,    _) => 0 [owise]
+    rule Ctxfloor(SCHED, CODE, ACCESSLISTTOKENS)
+      => Gtransaction < SCHED > +Int (Gtxdatafloor < SCHED > *Int ((lengthBytes(CODE) *Int 4) +Int ACCESSLISTTOKENS))
+      requires Ghasfloorcost << SCHED >> andBool Ghaseip7976 << SCHED >>
+
+    rule Ctxfloor(SCHED, CODE, _) => Gtransaction < SCHED > +Int (Gtxdatafloor < SCHED > *Int #tokensInCalldata(CODE))
+      requires Ghasfloorcost << SCHED >> andBool notBool Ghaseip7976 << SCHED >>
+
+    rule Ctxfloor(    _,    _, _) => 0 [owise]
 
     syntax Int ::= Cbls12g1MsmDiscount( Schedule , Int ) [symbol(Cbls12g1MsmDiscount), function, total, smtlib(gas_Cbls12g1MsmDiscount)]
                  | Cbls12g2MsmDiscount( Schedule , Int ) [symbol(Cbls12g2MsmDiscount), function, total, smtlib(gas_Cbls12g2MsmDiscount)]

kevm-pyk/src/kevm_pyk/kproj/evm-semantics/schedule.md

@@ -31,8 +31,8 @@ module SCHEDULE
                           | "Ghaswarmcoinbase"        | "Ghaswithdrawals"  | "Ghastransient"       | "Ghasmcopy"
                           | "Ghasbeaconroot"          | "Ghaseip6780"      | "Ghasblobbasefee"     | "Ghasblobhash"
                           | "Ghasbls12msmdiscount"    | "Ghashistory"      | "Ghasrequests"        | "Ghasauthority"
-                          | "Ghasfloorcost"           | "Ghasclz"
- // -------------------------------------------------------------
+                          | "Ghasfloorcost"           | "Ghasclz"          | "Ghaseip7976"         | "Ghaseip7981"
+ // ---------------------------------------------------------------------------------------------------------
 ```
 
 ### Schedule Constants
@@ -183,6 +183,8 @@ A `ScheduleConst` is a constant determined by the fee schedule.
     rule [GhasauthorityDefault]:           Ghasauthority           << DEFAULT >> => false
     rule [GhasfloorcostDefault]:           Ghasfloorcost           << DEFAULT >> => false
     rule [GhasclzDefault]:                 Ghasclz                 << DEFAULT >> => false
+    rule [Ghaseip7976Default]:             Ghaseip7976             << DEFAULT >> => false
+    rule [Ghaseip7981Default]:             Ghaseip7981             << DEFAULT >> => false
 ```
 
 ### Frontier Schedule
@@ -509,7 +511,31 @@ A `ScheduleConst` is a constant determined by the fee schedule.
     rule [GhasclzOsaka]:    Ghasclz    << OSAKA >> => true
     rule [SCHEDFLAGOsaka]:  SCHEDFLAG  << OSAKA >> => SCHEDFLAG << PRAGUE >>
       requires notBool ( SCHEDFLAG ==K Ghasclz )
-
+
+```
+
+### Amsterdam Schedule
+
+```k
+    syntax Schedule ::= "AMSTERDAM" [symbol(AMSTERDAM_EVM), smtlib(schedule_AMSTERDAM)]
+ // -----------------------------------------------------------------------------------
+    rule [GmaxblobgasAmsterdam]:               Gmaxblobgas               < AMSTERDAM > => 2752512
+    rule [GtargetblobgasAmsterdam]:            Gtargetblobgas            < AMSTERDAM > => 1835008
+    rule [BlobbasefeeupdatefractionAmsterdam]: Blobbasefeeupdatefraction < AMSTERDAM > => 11684671
+    rule [GtxdatafloorAmsterdam]:              Gtxdatafloor              < AMSTERDAM > => 16
+    rule [SCHEDCONSTAmsterdam]:                SCHEDCONST                < AMSTERDAM > => SCHEDCONST < OSAKA >
+      requires notBool ( SCHEDCONST ==K Gmaxblobgas
+                  orBool SCHEDCONST ==K Gtargetblobgas
+                  orBool SCHEDCONST ==K Blobbasefeeupdatefraction
+                  orBool SCHEDCONST ==K Gtxdatafloor
+                       )
+
+    rule [Ghaseip7976Amsterdam]: Ghaseip7976 << AMSTERDAM >> => true
+    rule [Ghaseip7981Amsterdam]: Ghaseip7981 << AMSTERDAM >> => true
+    rule [SCHEDFLAGAmsterdam]:   SCHEDFLAG   << AMSTERDAM >> => SCHEDFLAG << OSAKA >>
+      requires notBool ( SCHEDFLAG ==K Ghaseip7976
+                  orBool SCHEDFLAG ==K Ghaseip7981
+                       )
 ```
 
 ```k

kevm-pyk/src/kevm_pyk/kproj/evm-semantics/serialization.md

@@ -128,6 +128,8 @@ Address/Hash Helpers
                  | #blockHeaderHash(Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes       ) [function, symbol(blockHashHeaderBlobBeacon)      ]
                  | #blockHeaderHash(Int  , Int  , Int  , Int  , Int  , Int  , Bytes, Int  , Int  , Int  , Int  , Int  , Bytes, Int  , Int  , Int  , Int  , Int  , Int  , Int  , Int  ) [function, symbol(blockHeaderHashRequestsRoot)    ]
                  | #blockHeaderHash(Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes) [function, symbol(blockHashHeaderRequestsRoot)    ]
+                 | #blockHeaderHash(Int  , Int  , Int  , Int  , Int  , Int  , Bytes, Int  , Int  , Int  , Int  , Int  , Bytes, Int  , Int  , Int  , Int  , Int  , Int  , Int  , Int  , Int  , Int  ) [function, symbol(blockHeaderHashBALSlot)]
+                 | #blockHeaderHash(Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes, Bytes) [function, symbol(blockHashHeaderBALSlot)]
  // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
     rule #blockHeaderHash(HP:Bytes, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN)
@@ -199,6 +201,21 @@ Address/Hash Helpers
                                                 )
                                     )
                          )
+
+    rule #blockHeaderHash(HP:Bytes, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WF, UB, EB, BR, RR, HA, SN)
+         => #parseHexWord( Keccak256( #rlpEncode( [ HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WF, UB, EB, BR, RR, HA, SN] ) ) )
+
+    rule #blockHeaderHash(HP:Int, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WF, UB, EB, BR, RR, HA, SN)
+         => #parseHexWord( Keccak256( #rlpEncode( [ #wordBytes(HP), #wordBytes(HO), #addrBytes(HC)
+                                                  , #wordBytes(HR), #wordBytes(HT), #wordBytes(HE)
+                                                  , HB, HD, HI, HL, HG, HS, HX
+                                                  , #wordBytes(HM), #padToWidth(8, #asByteStack(HN))
+                                                  , HF , #wordBytes(WF) , UB , EB , #wordBytes(BR)
+                                                  , #wordBytes(RR) , #wordBytes(HA) , SN
+                                                  ]
+                                                )
+                                    )
+                         )
 ```
 
 - `#hashTxData` returns the Keccak-256 message hash `HT` to be signed.

kevm-pyk/src/kevm_pyk/kproj/evm-semantics/state-utils.md

@@ -78,6 +78,8 @@ module STATE-UTILS
          <excessBlobGas>     _ => 0          </excessBlobGas>
          <beaconRoot>        _ => 0          </beaconRoot>
          <requestsRoot>      _ => 0          </requestsRoot>
+         <balHash>           _ => 0          </balHash>
+         <slotNumber>        _ => 0          </slotNumber>
          <depositRequests>       _ => .Bytes </depositRequests>
          <withdrawalRequests>    _ => .Bytes </withdrawalRequests>
          <consolidationRequests> _ => .Bytes </consolidationRequests>
@@ -235,10 +237,22 @@ The `"rlp"` key loads the block information.
          </k>
          <requestsRoot> _ => #asWord(RR) </requestsRoot>
 
+    rule <k> load "rlp" : [ [ HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR, HA, SN, .JSONs ], BT, BU, BW, .JSONs ]
+          => load "rlp" : [ [ HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR, .JSONs ], BT, BU, BW, .JSONs ]
+         ...
+         </k>
+         <balHash>    _ => #asWord(HA) </balHash>
+         <slotNumber> _ => #asWord(SN) </slotNumber>
+
     // fallback rule to catch invalid rlp encodings
     rule <k> load "rlp" : _ => .K ... </k>
          <statusCode> _ => EVMC_INVALID_BLOCK </statusCode>  [owise]
 
+    rule <k> load "genesisRLP": [ [ HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR, HA, SN, .JSONs ], _, _, _, .JSONs ] => .K ... </k>
+         <blockhashes> .List => ListItem(#blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR, HA, SN)) ListItem(#asWord(HP)) </blockhashes>
+         <previousExcessBlobGas> 0 => #asWord(EB) </previousExcessBlobGas>
+         <previousBlobGasUsed>   0 => #asWord(UB) </previousBlobGasUsed>
+
     rule <k> load "genesisRLP": [ [ HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR, .JSONs ], _, _, _, .JSONs ] => .K ... </k>
          <blockhashes> .List => ListItem(#blockHeaderHash(HP, HO, HC, HR, HT, HE, HB, HD, HI, HL, HG, HS, HX, HM, HN, HF, WR, UB, EB, BR, RR)) ListItem(#asWord(HP)) </blockhashes>
          <previousExcessBlobGas> 0 => #asWord(EB) </previousExcessBlobGas>

kevm-pyk/src/tests/utils.py

@@ -60,7 +60,7 @@ def _skipped_tests(test_dir: Path, slow_tests_file: Path, failing_tests_file: Pa
 def read_csv_file(csv_file: Path) -> tuple[tuple[Path, str], ...]:
     with csv_file.open(newline='') as file:
         reader = csv.reader(file)
-        return tuple((Path(row[0]), row[1]) for row in reader)
+        return tuple((Path(row[0]), row[1]) for row in reader if row)
 
 
 def _test(

tests/execution-spec-tests/VERSION

@@ -1 +1 @@
-v5.4.0
+tests-glamsterdam-devnet@v7.2.0