1700 push zero

libethcore/ChainOperationParams.h

@@ -175,6 +175,7 @@ struct SChain {
     time_t verifyDaSigsPatchTimestamp = 0;
     time_t storageDestructionPatchTimestamp = 0;
     time_t powCheckPatchTimestamp = 0;
+    time_t pushZeroPatchTimestamp = 0;
     time_t skipInvalidTransactionsPatchTimestamp = 0;
 
     SChain() {

libethereum/ChainParams.cpp

@@ -266,6 +266,10 @@ ChainParams ChainParams::loadConfig(
                                        sChainObj.at( "powCheckPatchTimestamp" ).get_int64() :
                                        0;
 
+        s.pushZeroPatchTimestamp = sChainObj.count( "pushZeroPatchTimestamp" ) ?
+                                       sChainObj.at( "pushZeroPatchTimestamp" ).get_int64() :
+                                       0;
+
         s.skipInvalidTransactionsPatchTimestamp =
             sChainObj.count( "skipInvalidTransactionsPatchTimestamp" ) ?
                 sChainObj.at( "skipInvalidTransactionsPatchTimestamp" ).get_int64() :

libethereum/Client.cpp

@@ -54,6 +54,7 @@
 #include <libskale/ContractStorageLimitPatch.h>
 #include <libskale/ContractStorageZeroValuePatch.h>
 #include <libskale/POWCheckPatch.h>
+#include <libskale/PushZeroPatch.h>
 #include <libskale/RevertableFSPatch.h>
 #include <libskale/SkipInvalidTransactionsPatch.h>
 #include <libskale/State.h>
@@ -163,6 +164,7 @@ Client::Client( ChainParams const& _params, int _networkID,
     RevertableFSPatch::setTimestamp( chainParams().sChain.revertableFSPatchTimestamp );
     StorageDestructionPatch::setTimestamp( chainParams().sChain.storageDestructionPatchTimestamp );
     POWCheckPatch::setTimestamp( chainParams().sChain.powCheckPatchTimestamp );
+    PushZeroPatch::setTimestamp( chainParams().sChain.pushZeroPatchTimestamp );
     SkipInvalidTransactionsPatch::setTimestamp(
         this->chainParams().sChain.skipInvalidTransactionsPatchTimestamp );
 }
@@ -657,6 +659,7 @@ size_t Client::syncTransactions(
     RevertableFSPatch::lastBlockTimestamp = blockChain().info().timestamp();
     StorageDestructionPatch::lastBlockTimestamp = blockChain().info().timestamp();
     POWCheckPatch::lastBlockTimestamp = blockChain().info().timestamp();
+    PushZeroPatch::lastBlockTimestamp = blockChain().info().timestamp();
     SkipInvalidTransactionsPatch::lastBlockTimestamp = blockChain().info().timestamp();
 
     DEV_WRITE_GUARDED( x_working ) {

libethereum/ValidationSchemes.cpp

@@ -268,6 +268,8 @@ void validateConfigJson( js::mObject const& _obj ) {
             { "storageDestructionPatchTimestamp",
                 { { js::int_type }, JsonFieldPresence::Optional } },
             { "powCheckPatchTimestamp", { { js::int_type }, JsonFieldPresence::Optional } },
+            { "pushZeroPatchTimestamp", { { js::int_type }, JsonFieldPresence::Optional } },
+            { "nodeGroups", { { js::obj_type }, JsonFieldPresence::Optional } },
             { "nodeGroups", { { js::obj_type }, JsonFieldPresence::Optional } },
             { "skipInvalidTransactionsPatchTimestamp",
                 { { js::int_type }, JsonFieldPresence::Optional } } } );

libevm/Instruction.cpp

@@ -86,6 +86,10 @@ static const std::map<Instruction,  InstructionInfo> c_instructionInfo =
     { Instruction::MSIZE,        { "MSIZE",               0,    1,  Tier::Base } },
     { Instruction::GAS,          { "GAS",                 0,    1,  Tier::Base } },
     { Instruction::JUMPDEST,     { "JUMPDEST",            0,    0,  Tier::Special } },
+    // As per EIP-3855 PUSH0 instruction tire is base (2 gas units)
+    // As all other PUSH instructions, it removes zero elements from stack and
+    // pushes 1 element to stack
+    { Instruction::PUSH0,        { "PUSH0",               0,    1,  Tier::Base } },
     { Instruction::PUSH1,        { "PUSH1",               0,    1,  Tier::VeryLow } },
     { Instruction::PUSH2,        { "PUSH2",               0,    1,  Tier::VeryLow } },
     { Instruction::PUSH3,        { "PUSH3",               0,    1,  Tier::VeryLow } },

libevm/Instruction.h

@@ -94,6 +94,7 @@ enum class Instruction : uint8_t {
     GAS,         ///< get the amount of available gas
     JUMPDEST,    ///< set a potential jump destination
 
+    PUSH0 = 0x5f,  // EIP-3855
     PUSH1 = 0x60,  ///< place 1 byte item on stack
     PUSH2,         ///< place 2 byte item on stack
     PUSH3,         ///< place 3 byte item on stack

libevm/LegacyVM.cpp

@@ -16,6 +16,7 @@
 */
 
 #include "LegacyVM.h"
+#include "libskale/PushZeroPatch.h"
 
 using namespace std;
 using namespace dev;
@@ -1355,6 +1356,21 @@
         }
         CONTINUE
 
+        // EIP-3855. Code PUSH0 is similar to PUSH1 but pushes 0
+        // we need to increment program counter only by one since
+        // the value is not read from program code as in PUSH1
+        CASE( PUSH0 ) {
+            if ( !PushZeroPatch::isEnabled() ) {
+                throwBadInstruction();
+            }
+            ON_OP();
+            updateIOGas();
+            m_SPP[0] = 0;
+            ++m_PC;
+        };
+        CONTINUE
+
+
         CASE( PUSH1 ) {
             ON_OP();
             updateIOGas();

libevm/LegacyVMConfig.h

@@ -254,7 +254,7 @@ namespace eth {
         &&BEGINDATA,                            \
         &&BEGINSUB,                             \
         &&INVALID,                              \
-        &&INVALID,                              \
+        &&PUSH0, /* EIP-3855  */                \
         &&PUSH1, /* 60, */                      \
         &&PUSH2,                                \
         &&PUSH3,                                \

libskale/CMakeLists.txt

@@ -20,6 +20,7 @@ set(sources
     OverlayFS.cpp
     StorageDestructionPatch.cpp
     POWCheckPatch.cpp
+    PushZeroPatch.cpp
     SkipInvalidTransactionsPatch.cpp
 )
 

libskale/PushZeroPatch.cpp

@@ -0,0 +1,11 @@
+#include "PushZeroPatch.h"
+
+time_t PushZeroPatch::pushZeroPatchTimestamp;
+time_t PushZeroPatch::lastBlockTimestamp;
+
+bool PushZeroPatch::isEnabled() {
+    if ( pushZeroPatchTimestamp == 0 ) {
+        return false;
+    }
+    return pushZeroPatchTimestamp <= lastBlockTimestamp;
+}

libskale/PushZeroPatch.h

@@ -0,0 +1,27 @@
+#include <libethereum/SchainPatch.h>
+#include <time.h>
+
+namespace dev {
+namespace eth {
+class Client;
+}
+}  // namespace dev
+
+/*
+ * Context: enable effective storage destruction
+ */
+class PushZeroPatch : public SchainPatch {
+public:
+    static bool isEnabled();
+
+    static void setTimestamp( time_t _timeStamp ) {
+        printInfo( __FILE__, _timeStamp );
+        pushZeroPatchTimestamp = _timeStamp;
+    }
+
+
+private:
+    friend class dev::eth::Client;
+    static time_t pushZeroPatchTimestamp;
+    static time_t lastBlockTimestamp;
+};

test/historicstate/configs/basic_config.json

@@ -322,10 +322,11 @@
     "sChain":
     {
       "schainName": "TestChain",
-      "schainID": 1,
+      "schainID": 5,
       "schainOwner": "0x907cd0881E50d359bb9Fd120B1A5A143b1C97De6",
       "contractStorageLimit": 10000000000,
       "emptyBlockIntervalMs": 10000,
+      "pushZeroPatchTimestamp": 1,
       "nodes": [
         { "nodeID": 1112, "ip": "127.0.0.1", "basePort": 1231, "schainIndex" : 1, "publicKey":""}
       ]

test/historicstate/hardhat/contracts/Push0.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract Push0 {
+
+    uint256 public constant ZERO = 0;
+
+    function getZero() public {
+        // this triggers compiler using push0 to stack since operations use lots of zeros
+        uint256 one = 0;
+        one = one + 1  + ZERO;
+        uint256 two = one * 0;
+        uint256 three = one * ZERO;
+    }
+}

test/historicstate/hardhat/hardhat.config.js

@@ -10,7 +10,7 @@ module.exports = {
 const INSECURE_PRIVATE_KEY = "bd200f4e7f597f3c2c77fb405ee7fabeb249f63f03f43d5927b4fa0c43cfe85e";
 
 module.exports = {
-  solidity: "0.8.9",
+  solidity: "0.8.20",
   networks: {
     skaled: {
       url: `http://localhost:1234`,

test/historicstate/hardhat/scripts/push0_test.ts

@@ -0,0 +1,84 @@
+const OWNER_ADDRESS: string = "0x907cd0881E50d359bb9Fd120B1A5A143b1C97De6";
+const ZERO_ADDRESS: string = "0xO000000000000000000000000000000000000000";
+const INITIAL_MINT: bigint = 10000000000000000000000000000000000000000n;
+
+import {ethers} from "hardhat";
+
+async function waitUntilNextBlock() {
+
+    const current = await hre.ethers.provider.getBlockNumber();
+    let newBlock = current;
+    console.log(`BLOCK_NUMBER ${current}`);
+
+    while (newBlock == current) {
+        newBlock = await hre.ethers.provider.getBlockNumber();
+    }
+
+    console.log(`BLOCK_NUMBER ${newBlock}`);
+
+    return current;
+
+}
+
+function CHECK(result: any): void {
+    if (!result) {
+        const message: string = `Check failed ${result}`
+        console.log(message);
+        throw message;
+    }
+}
+
+async function getAndPrintTrace(hash: string): Promise<String> {
+//    const trace = await ethers.provider.send('debug_traceTransaction', [hash, {"tracer":"prestateTracer",
+//        "tracerConfig": {"diffMode":true}}]);
+
+//    const trace = await ethers.provider.send('debug_traceTransaction', [hash, {"tracer": "callTracer",
+//        "tracerConfig": {"withLog":true}}]);
+
+    const trace = await ethers.provider.send('debug_traceTransaction', [hash, {}]);
+
+
+
+    console.log(JSON.stringify(trace, null, 4));
+    return trace;
+}
+
+async function deployWriteAndDestroy(): Promise<void> {
+
+    console.log(`Deploying ...`);
+
+    const Push0Test = await ethers.getContractFactory("Push0");
+    const test = await Push0Test.deploy();
+    const testContract = await test.deployed();
+
+
+    const deployBn = await ethers.provider.getBlockNumber();
+
+    const hash = testContract.deployTransaction.hash;
+    console.log(`Gas limit ${testContract.deployTransaction.gasLimit}`);
+    console.log(`Contract deployed to ${testContract.address} at block ${deployBn} tx hash ${hash}`);
+
+
+    // await waitUntilNextBlock()
+
+    //await getAndPrintTrace(hash)
+
+
+    console.log(`Now testing`);
+
+    const transferReceipt = await testContract.getZero()
+    console.log(`Gas limit ${transferReceipt.gasLimit}`);
+
+
+}
+
+async function main(): Promise<void> {
+    await deployWriteAndDestroy();
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error: any) => {
+    console.error(error);
+    process.exitCode = 1;
+});