New beta

.github/workflows/functional-tests.yml

@@ -24,7 +24,7 @@
       with:
         token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
         repository: skalenetwork/skale-ci-integration_tests
-        ref: v3.18.0
+        ref: master
         submodules: recursive
     - name: Set up Node 
       uses: actions/[email protected]

VERSION

@@ -1 +1 @@
-3.18.1
+3.19.0

libdevcore/JsonUtils.cpp

@@ -57,10 +57,12 @@ std::string dev::jsonTypeAsString( json_spirit::Value_type _type ) {
 }
 
 void dev::requireJsonFields( json_spirit::mObject const& _o, std::string const& _config,
-    std::map< std::string, JsonFieldOptions > const& _validationMap ) {
+    std::map< std::string, JsonFieldOptions > const& _validationMap,
+    std::function< bool( const std::string& ) > _callbackForUnexpected ) {
     // check for unexpected fiedls
     for ( auto const& field : _o ) {
-        if ( !_validationMap.count( field.first ) ) {
+        // _callbackForUnexpected allows to accept ertain unexpected fields
+        if ( !_validationMap.count( field.first ) && !_callbackForUnexpected( field.first ) ) {
             std::string const comment =
                 "Unexpected field '" + field.first + "' in config: " + _config;
             cerror << comment << "\n"

libdevcore/JsonUtils.h

@@ -41,6 +41,10 @@ using JsonFieldOptions = std::pair< JsonTypeSet, JsonFieldPresence >;
   @param _validationMap a map with json objects that would be checked. "objName" -> {js::str_type,
   jsonField::Required}
 */
-void requireJsonFields( json_spirit::mObject const& _o, std::string const& _configName,
-    std::map< std::string, JsonFieldOptions > const& _validationMap );
+void requireJsonFields(
+    json_spirit::mObject const& _o, std::string const& _configName,
+    std::map< std::string, JsonFieldOptions > const& _validationMap,
+    std::function< bool( const std::string& ) > _callbackForUnexpected = []( const std::string& ) {
+        return false;
+    } );
 }  // namespace dev

libdevcore/LevelDB.h

@@ -26,8 +26,8 @@
 #include <leveldb/write_batch.h>
 #include <boost/filesystem.hpp>
 
-#include "shared_mutex"
 #include <secp256k1_sha256.h>
+#include <shared_mutex>
 
 namespace dev::db {
 class LevelDB : public DatabaseFace {

libethashseal/Ethash.cpp

@@ -130,18 +130,6 @@ void Ethash::verify( Strictness _s, BlockHeader const& _bi, BlockHeader const& _
     }
 }
 
-void Ethash::verifyTransaction( ImportRequirements::value _ir, TransactionBase const& _t,
-    BlockHeader const& _header, u256 const& _startGasUsed ) const {
-    SealEngineFace::verifyTransaction( _ir, _t, _header, _startGasUsed );
-
-    if ( _ir & ImportRequirements::TransactionSignatures ) {
-        if ( _header.number() >= chainParams().EIP158ForkBlock ) {
-            uint64_t chainID = chainParams().chainID;
-            _t.checkChainId( chainID, chainParams().skaleDisableChainIdCheck );
-        }  // if
-    }
-}
-
 u256 Ethash::childGasLimit( BlockHeader const& _bi, u256 const& _gasFloorTarget ) const {
     u256 gasFloorTarget = _gasFloorTarget == Invalid256 ? 3141562 : _gasFloorTarget;
     u256 gasLimit = _bi.gasLimit();

libethashseal/Ethash.h

@@ -52,8 +52,6 @@ class Ethash : public SealEngineBase {
     StringHashMap jsInfo( BlockHeader const& _bi ) const override;
     void verify( Strictness _s, BlockHeader const& _bi, BlockHeader const& _parent,
         bytesConstRef _block ) const override;
-    void verifyTransaction( ImportRequirements::value _ir, TransactionBase const& _t,
-        BlockHeader const& _header, u256 const& _startGasUsed ) const override;
     void populateFromParent( BlockHeader& _bi, BlockHeader const& _parent ) const override;
 
     strings sealers() const override;

libethcore/ChainOperationParams.cpp

@@ -22,6 +22,9 @@
  */
 
 #include "ChainOperationParams.h"
+
+#include <libethereum/SchainPatch.h>
+
 #include <libdevcore/CommonData.h>
 #include <libdevcore/Log.h>
 
@@ -42,6 +45,14 @@ PrecompiledContract::PrecompiledContract( unsigned _base, unsigned _word,
           },
           _exec, _startingBlock, _allowedAddresses ) {}
 
+time_t SChain::getPatchTimestamp( SchainPatchEnum _patchEnum ) const {
+    assert( _patchEnum < SchainPatchEnum::PatchesCount );
+    if ( _patchEnum < SchainPatchEnum::PatchesCount )
+        return _patchTimestamps[static_cast< size_t >( _patchEnum )];
+    else
+        return 0;
+}
+
 ChainOperationParams::ChainOperationParams()
     : m_blockReward( "0x4563918244F40000" ),
       minGasLimit( 0x1388 ),
@@ -52,43 +63,33 @@ ChainOperationParams::ChainOperationParams()
       difficultyBoundDivisor( 0x0800 ),
       durationLimit( 0x0d ) {}
 
-EVMSchedule const& ChainOperationParams::scheduleForBlockNumber( u256 const& _blockNumber ) const {
-    if ( _blockNumber >= skaleUnlimitedForkBlock )
-        return SkaleSchedule_Unlimited;
-    else if ( _blockNumber >= skale1024ForkBlock )
-        return SkaleSchedule_1024k;
-    else if ( _blockNumber >= skale512ForkBlock )
-        return SkaleSchedule_512k;
-    else if ( _blockNumber >= skale256ForkBlock )
-        return SkaleSchedule_256k;
-    else if ( _blockNumber >= skale128ForkBlock )
-        return SkaleSchedule_128k;
-    else if ( _blockNumber >= skale64ForkBlock )
-        return SkaleSchedule_64k;
-    else if ( _blockNumber >= skale32ForkBlock )
-        return SkaleSchedule_32k;
-    else if ( _blockNumber >= skale16ForkBlock )
-        return SkaleSchedule_16k;
-    else if ( _blockNumber >= experimentalForkBlock )
-        return ExperimentalSchedule;
-    else if ( _blockNumber >= istanbulForkBlock )
-        return IstanbulSchedule;
-    else if ( _blockNumber >= constantinopleFixForkBlock )
-        return ConstantinopleFixSchedule;
-    else if ( _blockNumber >= constantinopleForkBlock )
-        return ConstantinopleSchedule;
-    else if ( _blockNumber >= eWASMForkBlock )
-        return EWASMSchedule;
-    else if ( _blockNumber >= byzantiumForkBlock )
-        return ByzantiumSchedule;
-    else if ( _blockNumber >= EIP158ForkBlock )
-        return EIP158Schedule;
-    else if ( _blockNumber >= EIP150ForkBlock )
-        return EIP150Schedule;
-    else if ( _blockNumber >= homesteadForkBlock )
-        return HomesteadSchedule;
+EVMSchedule const ChainOperationParams::makeEvmSchedule(
+    time_t _committedBlockTimestamp, u256 const& _workingBlockNumber ) const {
+    EVMSchedule result;
+
+    // 1 decide by block number
+    if ( _workingBlockNumber >= experimentalForkBlock )
+        result = ExperimentalSchedule;
+    else if ( _workingBlockNumber >= istanbulForkBlock )
+        result = IstanbulSchedule;
+    else if ( _workingBlockNumber >= constantinopleFixForkBlock )
+        result = ConstantinopleFixSchedule;
+    else if ( _workingBlockNumber >= constantinopleForkBlock )
+        result = ConstantinopleSchedule;
+    else if ( _workingBlockNumber >= byzantiumForkBlock )
+        result = ByzantiumSchedule;
+    else if ( _workingBlockNumber >= EIP158ForkBlock )
+        result = EIP158Schedule;
+    else if ( _workingBlockNumber >= EIP150ForkBlock )
+        result = EIP150Schedule;
     else
-        return FrontierSchedule;
+        result = HomesteadSchedule;
+
+    // 2 based on previous - decide by timestamp
+    if ( PushZeroPatch::isEnabledWhen( _committedBlockTimestamp ) )
+        result = PushZeroPatch::makeSchedule( result );
+
+    return result;
 }
 
 u256 ChainOperationParams::blockReward( EVMSchedule const& _schedule ) const {
@@ -98,6 +99,16 @@ u256 ChainOperationParams::blockReward( EVMSchedule const& _schedule ) const {
         return m_blockReward;
 }
 
+u256 ChainOperationParams::blockReward(
+    time_t _committedBlockTimestamp, u256 const& _workingBlockNumber ) const {
+    EVMSchedule const& schedule{ makeEvmSchedule( _committedBlockTimestamp, _workingBlockNumber ) };
+    return blockReward( schedule );
+}
+
 void ChainOperationParams::setBlockReward( u256 const& _newBlockReward ) {
     m_blockReward = _newBlockReward;
 }
+
+time_t ChainOperationParams::getPatchTimestamp( SchainPatchEnum _patchEnum ) const {
+    return sChain.getPatchTimestamp( _patchEnum );
+}

libethcore/ChainOperationParams.h

@@ -28,6 +28,7 @@
 
 #include <libdevcore/Common.h>
 #include <libethereum/Precompiled.h>
+#include <libethereum/SchainPatchEnum.h>
 
 #include "libethcore/Common.h"
 #include "libethcore/EVMSchedule.h"
@@ -89,6 +90,7 @@ struct NodeInfo {
     bool syncNode;
     bool archiveMode;
     bool syncFromCatchup;
+    bool testSignatures;
 
     NodeInfo( std::string _name = "TestNode", u256 _id = 1, std::string _ip = "127.0.0.11",
         uint16_t _port = 11111, std::string _ip6 = "::1", uint16_t _port6 = 11111,
@@ -106,7 +108,8 @@ struct NodeInfo {
                 "11559732032986387107991004021392285783925812861821192530917403151452391805634",
                 "8495653923123431417604973247489272438418190587263600148770280649306958101930",
                 "4082367875863433681332203403145435568316851327593401208105741076214120093531" },
-        bool _syncNode = false, bool _archiveMode = false, bool _syncFromCatchup = false ) {
+        bool _syncNode = false, bool _archiveMode = false, bool _syncFromCatchup = false,
+        bool _testSignatures = true ) {
         name = _name;
         id = _id;
         ip = _ip;
@@ -121,6 +124,7 @@ struct NodeInfo {
         syncNode = _syncNode;
         archiveMode = _archiveMode;
         syncFromCatchup = _syncFromCatchup;
+        testSignatures = _testSignatures;
     }
 };
 
@@ -173,16 +177,12 @@ struct SChain {
     int emptyBlockIntervalMs = -1;
     int64_t levelDBReopenIntervalMs = -1;
     size_t t = 1;
-    time_t revertableFSPatchTimestamp = 0;
-    time_t contractStoragePatchTimestamp = 0;
-    time_t contractStorageZeroValuePatchTimestamp = 0;
-    time_t verifyDaSigsPatchTimestamp = 0;
-    time_t storageDestructionPatchTimestamp = 0;
-    time_t powCheckPatchTimestamp = 0;
-    time_t precompiledConfigPatchTimestamp = 0;
-    time_t pushZeroPatchTimestamp = 0;
-    time_t skipInvalidTransactionsPatchTimestamp = 0;
-    time_t correctForkInPowPatchTimestamp = 0;
+
+    // key is patch name
+    // public - for tests, don't access it directly
+    std::vector< time_t > _patchTimestamps =
+        std::vector< time_t >( static_cast< int >( SchainPatchEnum::PatchesCount ) );
+    time_t getPatchTimestamp( SchainPatchEnum _patchEnum ) const;
 
     SChain() {
         name = "TestChain";
@@ -210,8 +210,10 @@ struct ChainOperationParams {
     u256 m_blockReward;
 
 public:
-    EVMSchedule const& scheduleForBlockNumber( u256 const& _blockNumber ) const;
+    EVMSchedule const makeEvmSchedule(
+        time_t _committedBlockTimestamp, u256 const& _workingBlockNumber ) const;
     u256 blockReward( EVMSchedule const& _schedule ) const;
+    u256 blockReward( time_t _committedBlockTimestamp, u256 const& _workingBlockNumber ) const;
     void setBlockReward( u256 const& _newBlockReward );
     u256 maximumExtraDataSize = 1024;
     u256 accountStartNonce = 0;
@@ -257,6 +259,25 @@ struct ChainOperationParams {
     u256 externalGasDifficulty = ~u256( 0 );
     typedef std::vector< std::string > vecAdminOrigins_t;
     vecAdminOrigins_t vecAdminOrigins;  // wildcard based folters for IP addresses
+    int getLogsBlocksLimit = -1;
+
+    time_t getPatchTimestamp( SchainPatchEnum _patchEnum ) const;
+
+    bool isPrecompiled( Address const& _a, u256 const& _blockNumber ) const {
+        return precompiled.count( _a ) != 0 && _blockNumber >= precompiled.at( _a ).startingBlock();
+    }
+    bigint costOfPrecompiled(
+        Address const& _a, bytesConstRef _in, u256 const& _blockNumber ) const {
+        return precompiled.at( _a ).cost( _in, *this, _blockNumber );
+    }
+    std::pair< bool, bytes > executePrecompiled(
+        Address const& _a, bytesConstRef _in, u256 const& ) const {
+        return precompiled.at( _a ).execute( _in );
+    }
+    bool precompiledExecutionAllowedFrom(
+        Address const& _a, Address const& _from, bool _readOnly ) const {
+        return precompiled.at( _a ).executionAllowedFrom( _from, _readOnly );
+    }
 };
 
 }  // namespace eth

libethcore/Common.cpp

@@ -109,9 +109,26 @@ std::string formatBalance( bigint const& _b ) {
 }
 
 bytes isAddressWhitelistedCallData( Address const& _deployer ) {
+    // Generating calldata for isAddressWhitelisted contract call:
+    // 13f44d1 - selector of isAddressWhitelisted function
+    // 000000000000000000000000 - 12-byte offset for sender address
+    // _deployer - 20-byte sender address
+
     return fromHex( "13f44d10000000000000000000000000" + _deployer.hex() );
 }
 
+bytes isDeploymentAllowedCallData( Address const& _origin, Address const& _deployer ) {
+    // Generating calldata for isDeploymentAllowed contract call:
+    // d0f557f4 - selector of isDeploymentAllowed function
+    // 000000000000000000000000 - 12-byte offset for origin address
+    // _origin - 20-byte origin address
+    // 000000000000000000000000 - 12-byte offset for sender address
+    // _deployer - 20-byte sender address
+
+    return fromHex( "d0f557f4000000000000000000000000" + _origin.hex() +
+                    "000000000000000000000000" + _deployer.hex() );
+}
+
 bytes getMultitransactionCallData() {
     return fromHex( "0xbad0396e" );
 }

libethcore/Common.h

@@ -58,9 +58,12 @@ extern const bytes c_blockhashContractCode;
 /// Address of the special contract for deployment control
 extern const Address c_configControllerContractAddress;
 
-/// Formatting call data for deployment control contract
+/// Generating call data for deployment control contract
 bytes isAddressWhitelistedCallData( Address const& _deployer );
 
+/// Generating calldata for deployment control contract, considering tx origin
+bytes isDeploymentAllowedCallData( Address const& _origin, Address const& _deployer );
+
 /// Formatting call data for multitransaction contract
 bytes getMultitransactionCallData();