Bug/1702 adopt precompiled oracle

libethcore/ChainOperationParams.h

@@ -140,6 +140,7 @@ struct GroupNode {
     u256 id;
     u256 schainIndex;
     std::string publicKey;
+    std::string address;
 };
 
 /// skale
@@ -175,6 +176,7 @@ struct SChain {
     time_t verifyDaSigsPatchTimestamp = 0;
     time_t storageDestructionPatchTimestamp = 0;
     time_t powCheckPatchTimestamp = 0;
+    time_t precompiledConfigPatchTimestamp = 0;
     time_t pushZeroPatchTimestamp = 0;
     time_t skipInvalidTransactionsPatchTimestamp = 0;
 

libethereum/ChainParams.cpp

@@ -266,6 +266,11 @@
                                        sChainObj.at( "powCheckPatchTimestamp" ).get_int64() :
                                        0;
 
+        s.precompiledConfigPatchTimestamp =
+            sChainObj.count( "precompiledConfigPatchTimestamp" ) ?
+                sChainObj.at( "precompiledConfigPatchTimestamp" ).get_int64() :
+                0;
+
         s.pushZeroPatchTimestamp = sChainObj.count( "pushZeroPatchTimestamp" ) ?
                                        sChainObj.at( "pushZeroPatchTimestamp" ).get_int64() :
                                        0;
@@ -288,10 +293,17 @@
                 auto groupNodesObj = nodeGroupObj["nodes"].get_obj();
                 for ( const auto& groupNodeConf : groupNodesObj ) {
                     auto groupNodeConfObj = groupNodeConf.second.get_array();
-                    u256 sChainIndex = groupNodeConfObj[0].get_uint64();
-                    u256 id = groupNodeConfObj[1].get_uint64();
-                    std::string publicKey = groupNodeConfObj[2].get_str();
-                    groupNodes.push_back( { id, sChainIndex, publicKey } );
+                    u256 sChainIndex = groupNodeConfObj.at( 0 ).get_uint64();
+                    u256 id = groupNodeConfObj.at( 1 ).get_uint64();
+                    std::string publicKey = groupNodeConfObj.at( 2 ).get_str();
+                    std::string address = groupNodeConfObj.at( 3 ).get_str();
+                    if ( publicKey.empty() ) {
+                        BOOST_THROW_EXCEPTION( std::runtime_error( "Empty public key in config" ) );
+                    }
+                    if ( address.empty() ) {
+                        BOOST_THROW_EXCEPTION( std::runtime_error( "Empty address in config" ) );
+                    }
+                    groupNodes.push_back( { id, sChainIndex, publicKey, address } );
                 }
                 std::sort( groupNodes.begin(), groupNodes.end(),
                     []( const GroupNode& lhs, const GroupNode& rhs ) {

libethereum/Client.cpp

@@ -54,6 +54,7 @@
 #include <libskale/ContractStorageLimitPatch.h>
 #include <libskale/ContractStorageZeroValuePatch.h>
 #include <libskale/POWCheckPatch.h>
+#include <libskale/PrecompiledConfigPatch.h>
 #include <libskale/PushZeroPatch.h>
 #include <libskale/RevertableFSPatch.h>
 #include <libskale/SkipInvalidTransactionsPatch.h>
@@ -167,6 +168,7 @@
     PushZeroPatch::setTimestamp( chainParams().sChain.pushZeroPatchTimestamp );
     SkipInvalidTransactionsPatch::setTimestamp(
         this->chainParams().sChain.skipInvalidTransactionsPatchTimestamp );
+    PrecompiledConfigPatch::setTimestamp( chainParams().sChain.precompiledConfigPatchTimestamp );
 }
 
 
@@ -313,8 +315,12 @@
     if ( m_dbPath.size() )
         Defaults::setDBPath( m_dbPath );
 
-    if ( ChainParams().sChain.nodeGroups.size() > 0 )
-        initIMABLSPublicKey();
+    if ( chainParams().sChain.nodeGroups.size() > 0 ) {
+        initHistoricGroupIndex();
+    } else {
+        LOG( m_logger ) << "Empty node groups in config. "
+                           "This is OK in tests but not OK in production";
+    }
 
     // init snapshots for not newly created chains
     if ( number() ) {
@@ -621,7 +627,7 @@
     }
 
     if ( chainParams().sChain.nodeGroups.size() > 0 )
-        updateIMABLSPublicKey();
+        updateHistoricGroupIndex();
 
     m_snapshotAgent->doSnapshotIfNeeded( number(), _timestamp );
 
@@ -661,6 +667,7 @@
     POWCheckPatch::lastBlockTimestamp = blockChain().info().timestamp();
     PushZeroPatch::lastBlockTimestamp = blockChain().info().timestamp();
     SkipInvalidTransactionsPatch::lastBlockTimestamp = blockChain().info().timestamp();
+    PrecompiledConfigPatch::lastBlockTimestamp = blockChain().info().timestamp();
 
     DEV_WRITE_GUARDED( x_working ) {
         assert( !m_working.isSealed() );
@@ -1288,9 +1295,9 @@
     return ret;
 }
 
-void Client::initIMABLSPublicKey() {
+void Client::initHistoricGroupIndex() {
     if ( number() == 0 ) {
-        imaBLSPublicKeyGroupIndex = 0;
+        historicGroupIndex = 0;
         return;
     }
 
@@ -1302,7 +1309,11 @@
         chainParams().sChain.nodeGroups.end(),
         [&currentBlockTimestamp](
             const dev::eth::NodeGroup& ng ) { return currentBlockTimestamp <= ng.finishTs; } );
-    assert( it != chainParams().sChain.nodeGroups.end() );
+
+    if ( it == chainParams().sChain.nodeGroups.end() ) {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error( "Assertion failed: it == chainParams().sChain.nodeGroups.end()" ) );
+    }
 
     if ( it != chainParams().sChain.nodeGroups.begin() ) {
         auto prevIt = std::prev( it );
@@ -1311,15 +1322,18 @@
             it = prevIt;
     }
 
-    imaBLSPublicKeyGroupIndex = std::distance( chainParams().sChain.nodeGroups.begin(), it );
+    historicGroupIndex = std::distance( chainParams().sChain.nodeGroups.begin(), it );
 }
 
-void Client::updateIMABLSPublicKey() {
+void Client::updateHistoricGroupIndex() {
     uint64_t blockTimestamp = blockInfo( hashFromNumber( number() ) ).timestamp();
-    uint64_t currentFinishTs = chainParams().sChain.nodeGroups[imaBLSPublicKeyGroupIndex].finishTs;
+    uint64_t currentFinishTs = chainParams().sChain.nodeGroups[historicGroupIndex].finishTs;
     if ( blockTimestamp >= currentFinishTs )
-        ++imaBLSPublicKeyGroupIndex;
-    assert( imaBLSPublicKeyGroupIndex < chainParams().sChain.nodeGroups.size() );
+        ++historicGroupIndex;
+    if ( historicGroupIndex >= chainParams().sChain.nodeGroups.size() ) {
+        BOOST_THROW_EXCEPTION( std::runtime_error(
+            "Assertion failed: historicGroupIndex >= chainParams().sChain.nodeGroups.size())" ) );
+    }
 }
 
 // new block watch

libethereum/Client.h

@@ -297,7 +297,22 @@ class Client : public ClientBase, protected Worker {
     }
 
     std::array< std::string, 4 > getIMABLSPublicKey() const {
-        return chainParams().sChain.nodeGroups[imaBLSPublicKeyGroupIndex].blsPublicKey;
+        return chainParams().sChain.nodeGroups[historicGroupIndex].blsPublicKey;
+    }
+
+    // get node id for historic node in chain
+    std::string getHistoricNodeId( unsigned _id ) const {
+        return chainParams().sChain.nodeGroups[historicGroupIndex].nodes[_id].id.str();
+    }
+
+    // get schain index for historic node in chain
+    std::string getHistoricNodeIndex( unsigned _idx ) const {
+        return chainParams().sChain.nodeGroups[historicGroupIndex].nodes[_idx].schainIndex.str();
+    }
+
+    // get node owner for historic node in chain
+    std::string getHistoricNodeOwner( unsigned _idx ) const {
+        return chainParams().sChain.nodeGroups[historicGroupIndex].nodes[_idx].address;
     }
 
     void doStateDbCompaction() const { m_state.getOriginalDb()->doCompaction(); }
@@ -532,10 +547,11 @@ class Client : public ClientBase, protected Worker {
     fs::path m_dbPath;
 
 private:
-    void initIMABLSPublicKey();
-    void updateIMABLSPublicKey();
+    void initHistoricGroupIndex();
+    void updateHistoricGroupIndex();
 
-    unsigned imaBLSPublicKeyGroupIndex = 0;
+    // which group corresponds to the current block timestamp on this node
+    unsigned historicGroupIndex = 0;
 
 public:
     FILE* performance_fd;

libethereum/Precompiled.cpp

@@ -26,6 +26,7 @@
 #include <cryptopp/files.h>
 #include <cryptopp/hex.h>
 #include <cryptopp/sha.h>
+#include <libdevcore/CommonJS.h>
 #include <libdevcore/FileSystem.h>
 #include <libdevcore/Log.h>
 #include <libdevcore/SHA3.h>
@@ -36,8 +37,11 @@
 #include <libethcore/ChainOperationParams.h>
 #include <libethcore/Common.h>
 #include <libethereum/SkaleHost.h>
+#include <libskale/PrecompiledConfigPatch.h>
 #include <libskale/State.h>
 #include <boost/algorithm/hex.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
 
 #include <mutex>
 
@@ -673,25 +677,7 @@
     return { false, response };  // 1st false - means bad error occur
 }
 
-static const std::list< std::string > g_listReadableConfigParts{ "sealEngine",
-    //"genesis.*"
-    //"params.*",
-
-    "skaleConfig.nodeInfo.wallets.ima.commonBLSPublicKey*",
-    "skaleConfig.nodeInfo.wallets.ima.BLSPublicKey*",
-
-    "skaleConfig.nodeInfo.nodeName", "skaleConfig.nodeInfo.nodeID",
-    "skaleConfig.nodeInfo.basePort*", "skaleConfig.nodeInfo.*RpcPort*",
-    "skaleConfig.nodeInfo.acceptors", "skaleConfig.nodeInfo.max-connections",
-    "skaleConfig.nodeInfo.max-http-queues", "skaleConfig.nodeInfo.ws-mode",
-
-    "skaleConfig.contractSettings.*",
-
-    "skaleConfig.sChain.emptyBlockIntervalMs",
-
-    "skaleConfig.sChain.schainName", "skaleConfig.sChain.schainID",
-
-    "skaleConfig.sChain.nodes.*" };
+static const std::list< std::string > g_listReadableConfigParts{ "skaleConfig.sChain.nodes." };
 
 static bool stat_is_accessible_json_path( const std::string& strPath ) {
     if ( strPath.empty() )
@@ -700,7 +686,7 @@
                                              itEnd = g_listReadableConfigParts.cend();
     for ( ; itWalk != itEnd; ++itWalk ) {
         const std::string strWildCard = ( *itWalk );
-        if ( skutils::tools::wildcmp( strWildCard.c_str(), strPath.c_str() ) )
+        if ( boost::algorithm::starts_with( strPath, strWildCard ) )
             return true;
     }
     return false;
@@ -756,6 +742,48 @@
     return uValue;
 }
 
+static bool isCallToHistoricData( const std::string& callData ) {
+    // in C++ 20 there is string::starts_with, but we do not use C++ 20 yet
+    return boost::algorithm::starts_with( callData, "skaleConfig.sChain.nodes." );
+}
+
+static std::pair< std::string, unsigned > parseHistoricFieldRequest( std::string callData ) {
+    std::vector< std::string > splitted;
+    boost::split( splitted, callData, boost::is_any_of( "." ) );
+    // first 3 elements are skaleConfig, sChain, nodes - it was checked before
+    unsigned id = std::stoul( splitted.at( 3 ) );
+    std::string fieldName;
+    boost::trim_if( splitted.at( 4 ), []( char c ) { return c == '\0'; } );
+    std::set< std::string > allowedValues{ "id", "schainIndex", "owner" };
+    fieldName = splitted.at( 4 );
+    if ( allowedValues.count( fieldName ) ) {
+        return { fieldName, id };
+    } else {
+        BOOST_THROW_EXCEPTION( std::runtime_error( "Unknown field:" + fieldName ) );
+    }
+    return { fieldName, id };
+}
+
+/*
+ * this precompiled contract is designed to get access to specific integer config values
+ * and works as key / values map
+ * input: bytes - length + path to config variable
+ * output: bytes - config variable value
+ *
+ * variables available through this precompiled contract:
+ * 1. id - node id for INDEX node in schain group for current block number
+ * 2. schainIndex - schain index for INDEX node in schain group for current block number
+ * to access those variables one should use the following scheme:
+ * prefix=skaleConfig.sChain.nodes - to access corresponding structure inside skaled
+ * index - node index user wants to get access to
+ * field - the field user wants to request
+ *
+ * example:
+ * to request the value for 1-st node (1 based) for the node id field the input should be
+ * input=skaleConfig.sChain.nodes.0.id (inside skaled node indexes are 0 based)
+ * so one should pass the following as calldata:
+ * toBytes( ( ( input.length + 1 ) / 32 ) * 32) + toBytes(input)
+ */
 ETH_REGISTER_PRECOMPILED( getConfigVariableUint256 )( bytesConstRef _in ) {
     try {
         size_t lengthName;
@@ -767,18 +795,33 @@
 
         if ( !g_configAccesssor )
             throw std::runtime_error( "Config accessor was not initialized" );
-        nlohmann::json joConfig = g_configAccesssor->getConfigJSON();
-        nlohmann::json joValue =
-            skutils::json_config_file_accessor::stat_extract_at_path( joConfig, rawName );
-        std::string strValue = skutils::tools::trim_copy(
-            joValue.is_string() ? joValue.get< std::string >() : joValue.dump() );
 
-        // dev::u256 uValue( strValue.c_str() );
-        dev::u256 uValue = stat_parse_u256_hex_or_dec( strValue );
-        // std::cout << "------------ Loaded config var \""
-        //          << rawName << "\" value is " << uValue
-        //          << "\n";
+        std::string strValue;
+        // call to skaleConfig.sChain.nodes means call to the historic data
+        // need to proccess it in a different way
+        if ( isCallToHistoricData( rawName ) && PrecompiledConfigPatch::isEnabled() ) {
+            if ( !g_skaleHost )
+                throw std::runtime_error( "SkaleHost accessor was not initialized" );
+
+            std::string field;
+            unsigned id;
+            std::tie( field, id ) = parseHistoricFieldRequest( rawName );
+            if ( field == "id" ) {
+                strValue = g_skaleHost->getHistoricNodeId( id );
+            } else if ( field == "schainIndex" ) {
+                strValue = g_skaleHost->getHistoricNodeIndex( id );
+            } else {
+                throw std::runtime_error( "Incorrect config field" );
+            }
+        } else {
+            nlohmann::json joConfig = g_configAccesssor->getConfigJSON();
+            nlohmann::json joValue =
+                skutils::json_config_file_accessor::stat_extract_at_path( joConfig, rawName );
+            strValue = skutils::tools::trim_copy(
+                joValue.is_string() ? joValue.get< std::string >() : joValue.dump() );
+        }
 
+        dev::u256 uValue = jsToInt( strValue );
         bytes response = toBigEndian( uValue );
         return { true, response };
     } catch ( std::exception& ex ) {
@@ -796,6 +839,25 @@
     return { false, response };  // 1st false - means bad error occur
 }
 
+/*
+ * this precompiled contract is designed to get access to specific config values that are ETH
+ * addresses and works as key / values map input: bytes - length + path to config variable output:
+ * bytes - config variable value
+ *
+ * variables available through this precompiled contract:
+ * 1. owner - address for INDEX node in schain group for current block number
+ * to access those variables one should use the following scheme:
+ * prefix=skaleConfig.sChain.nodes - to access corresponding structure inside skaled
+ * index - node index user wants to get access to
+ * field - the field user wants to request
+ *
+ * example:
+ * to request the value for 2-nd node (1 based) for the owner field the input should be
+ * input=skaleConfig.sChain.nodes.1.owner (inside skaled node indexes are 0 based)
+ * so one should pass the following as calldata
+ * toBytes( ( ( input.length + 1 ) / 32 ) * 32) + toBytes(input)
+ *
+ */
 ETH_REGISTER_PRECOMPILED( getConfigVariableAddress )( bytesConstRef _in ) {
     try {
         size_t lengthName;
@@ -807,13 +869,31 @@
 
         if ( !g_configAccesssor )
             throw std::runtime_error( "Config accessor was not initialized" );
-        nlohmann::json joConfig = g_configAccesssor->getConfigJSON();
-        nlohmann::json joValue =
-            skutils::json_config_file_accessor::stat_extract_at_path( joConfig, rawName );
-        std::string strValue = skutils::tools::trim_copy(
-            joValue.is_string() ? joValue.get< std::string >() : joValue.dump() );
-        dev::u256 uValue( strValue.c_str() );
 
+        std::string strValue;
+        // call to skaleConfig.sChain.nodes means call to the historic data
+        // need to proccess it in a different way
+        if ( isCallToHistoricData( rawName ) && PrecompiledConfigPatch::isEnabled() ) {
+            if ( !g_skaleHost )
+                throw std::runtime_error( "SkaleHost accessor was not initialized" );
+
+            std::string field;
+            unsigned id;
+            std::tie( field, id ) = parseHistoricFieldRequest( rawName );
+            if ( field == "owner" ) {
+                strValue = g_skaleHost->getHistoricNodeOwner( id );
+            } else {
+                throw std::runtime_error( "Incorrect config field" );
+            }
+        } else {
+            nlohmann::json joConfig = g_configAccesssor->getConfigJSON();
+            nlohmann::json joValue =
+                skutils::json_config_file_accessor::stat_extract_at_path( joConfig, rawName );
+            strValue = skutils::tools::trim_copy(
+                joValue.is_string() ? joValue.get< std::string >() : joValue.dump() );
+        }
+
+        dev::u256 uValue( strValue );
         bytes response = toBigEndian( uValue );
         return { true, response };
     } catch ( std::exception& ex ) {