feat(poc): decentralized bridge approach witnet#2

Author: guidiaz

contracts/data/WitnetBlocksData.sol

@@ -13,7 +13,18 @@ abstract contract WitnetBlocksData {
         0x28b1d7e478138a94698f82768889fd6edf6b777bb6815c200552870d3e78ffb5;
 
     struct Storage {
-        WitnetV2.Beacon lastBeacon;
+        uint256 lastBeaconIndex;
+        uint256 nextBeaconIndex;
+        uint256 latestBeaconIndex;
+        mapping (/* beacon index */ uint256 => WitnetV2.Beacon) beacons;
+        mapping (/* beacon index */ uint256 => uint256) beaconSuccessorOf;
+        mapping (/* beacon index */ uint256 => BeaconTracks) beaconTracks;
+    }
+
+    struct BeaconTracks {
+        mapping (bytes32 => bool) disputed;
+        bytes32[] queries;
+        uint256 offset;
     }
 
     // ================================================================================================
@@ -29,4 +40,8 @@ abstract contract WitnetBlocksData {
         }
     }
 
+    function __tracks_(uint256 beaconIndex) internal view returns (BeaconTracks storage) {
+        return __blocks().beaconTracks[beaconIndex];
+    }
+
 }

contracts/data/WitnetRequestBoardV2Data.sol

@@ -14,9 +14,14 @@ abstract contract WitnetRequestBoardV2Data {
       0xfeed002ff8a708dcba69bac2a8e829fd61fee551b9e9fc0317707d989cb0fe53;
 
     struct Storage {
-      uint256 nonce;
       mapping (address => Escrow) escrows;
-      mapping (bytes32 => WitnetV2.Query) queries;
+      mapping (/* queryHash */ bytes32 => WitnetV2.Query) queries;
+      mapping (/* tallyHash */ bytes32 => Suitor) suitors;
+    }
+
+    struct Suitor {
+      uint256 index;
+      bytes32 queryHash;
     }
 
     struct Escrow {
@@ -55,55 +60,4 @@ abstract contract WitnetRequestBoardV2Data {
             _ptr.slot := _WITNET_BOARD_DATA_SLOTHASH
         }
     }
-
-    /// Gets current status of given query.
-    function _statusOf(bytes32 queryHash, IWitnetBlocks blocks)
-      internal view
-      returns (WitnetV2.QueryStatus)
-    {
-      WitnetV2.Query storage __query = __query_(queryHash);
-      if (__query.reporter != address(0) || __query.disputes.length > 0) {
-        if (blocks.getLastBeaconIndex() >= __query.epoch) {
-          return WitnetV2.QueryStatus.Finalized;
-        } else {
-          if (__query.disputes.length > 0) {
-            return WitnetV2.QueryStatus.Disputed;
-          } else {
-            return WitnetV2.QueryStatus.Reported;
-          }
-        }
-      } else if (__query.from != address(0)) {
-        return WitnetV2.checkQueryPostStatus(
-          __query.epoch, 
-          blocks.getCurrentBeaconIndex()
-        );
-      } else {
-        return WitnetV2.QueryStatus.Void;
-      }
-    }
-
-    function _statusOfRevertMessage(WitnetV2.QueryStatus queryStatus)
-      internal pure
-      returns (string memory)
-    {
-      string memory _reason;
-      if (queryStatus == WitnetV2.QueryStatus.Posted) {
-        _reason = "Posted";
-      } else if (queryStatus == WitnetV2.QueryStatus.Reported) {
-        _reason = "Reported";
-      } else if (queryStatus == WitnetV2.QueryStatus.Disputed) {
-        _reason = "Disputed";
-      } else if (queryStatus == WitnetV2.QueryStatus.Expired) {
-        _reason = "Expired";
-      } else if (queryStatus == WitnetV2.QueryStatus.Finalized) {
-        _reason = "Finalized";
-      } else {
-        _reason = "expected";
-      }
-      return string(abi.encodePacked(
-        "WitnetRequestBoardV2Data: not in ", 
-        _reason,
-        " status"
-      ));
-    }
 }

contracts/impls/core/WitnetBlocksDefault.sol

@@ -14,15 +14,19 @@ contract WitnetBlocksDefault
         WitnetBlocksData,
         WitnetUpgradableBase
 {
-    IWitnetRequestBoardV2 override immutable public board;
+    using WitnetV2 for WitnetV2.Beacon;
+
+    IWitnetRequestBoardV2 immutable public override board;
+    uint256 immutable internal __genesisIndex;
 
-    uint256 immutable internal __genesis_index;
-    bytes32 immutable internal __genesis_root;
+    uint256 immutable public override ROLLUP_DEFAULT_PENALTY_WEI;
+    uint256 immutable public override ROLLUP_MAX_GAS;
 
     constructor(
-            uint256 _genesisIndex,
-            bytes32 _genesisRoot,
             address _counterFactualAddress,
+            WitnetV2.Beacon memory _genesis,
+            uint256 _rollupDefaultPenaltyWei,
+            uint256 _rollupMaxGas,
             bool _upgradable,
             bytes32 _versionTag
         )
@@ -32,17 +36,15 @@ contract WitnetBlocksDefault
             "io.witnet.proxiable.blocks"
         )
     {
+        assert(_counterFactualAddress != address(0));
+        assert(_rollupDefaultPenaltyWei > 0);
+        assert(_rollupMaxGas > 0);
         board = IWitnetRequestBoardV2(_counterFactualAddress);
-        __blocks().lastBeacon = WitnetV2.Beacon({
-            index: _genesisIndex,
-            root: _genesisRoot
-        });
-        __genesis_index = _genesisIndex;
-        __genesis_root = _genesisRoot; 
-    }
-    
-    function class() virtual override(WitnetUpgradableBase, IWitnetBlocks) external pure returns (bytes4) {
-        return type(IWitnetBlocks).interfaceId;
+        __genesisIndex = _genesis.index;
+        __blocks().beacons[__genesisIndex] = _genesis;
+        __blocks().lastBeaconIndex = _genesis.index;
+        ROLLUP_DEFAULT_PENALTY_WEI = _rollupDefaultPenaltyWei;
+        ROLLUP_MAX_GAS = _rollupMaxGas;        
     }
 
 
@@ -70,17 +72,23 @@ contract WitnetBlocksDefault
         }
         require(
             __proxiable().implementation != base(),
-            "WitnetBlocks: already initialized"
+            "WitnetBlocksDefault: already initialized"
         );
         if (initdata.length > 0) {
             WitnetV2.Beacon memory _checkpoint = abi.decode(initdata, (WitnetV2.Beacon));
-            uint256 _lastBeaconIndex = __blocks().lastBeacon.index;
+            uint256 _lastBeaconIndex = __blocks().lastBeaconIndex;
+            uint256 _nextBeaconIndex = __blocks().nextBeaconIndex;
             require(
                 _checkpoint.index > _lastBeaconIndex,
-                "WitnetBlocksDefault: illegal rollback"
+                "WitnetBlocksDefault: cannot rollback"
             );
-            __blocks().lastBeacon = _checkpoint;
-            emit Rollup(msg.sender, _checkpoint.index, _lastBeaconIndex);
+            require(
+                _nextBeaconIndex == 0 || _checkpoint.index < _nextBeaconIndex,
+                "WitnetBlocksDefault: pending rollups"
+            );
+            __blocks().lastBeaconIndex = _checkpoint.index;
+            __blocks().beacons[_checkpoint.index] = _checkpoint;
+            emit FastForward(msg.sender, _checkpoint.index, _lastBeaconIndex);
         }
         __proxiable().implementation = base();
         emit Upgraded(msg.sender, base(), codehash(), version());
@@ -99,47 +107,190 @@ contract WitnetBlocksDefault
     // ================================================================================================================
     // --- Implementation of 'IWitnetBlocks' --------------------------------------------------------------------------
 
+    function class() virtual override(WitnetUpgradableBase, IWitnetBlocks) external pure returns (bytes4) {
+        return type(IWitnetBlocks).interfaceId;
+    }
+    
     function genesis()
         virtual override
         external view
         returns (WitnetV2.Beacon memory)
     {
-        return WitnetV2.Beacon({
-            index: __genesis_index,
-            root: __genesis_root
-        });
+        return __blocks().beacons[__genesisIndex];
+    }
+
+    function getBeaconDisputedQueries(uint256 beaconIndex)
+        virtual override
+        external view
+        returns (bytes32[] memory)
+    {
+        return __tracks_(beaconIndex).queries;
+    }
+
+    function getCurrentBeaconIndex()
+        virtual override
+        public view
+        returns (uint256)
+    {
+        // solhint-disable not-rely-on-time
+        return WitnetV2.beaconIndexFromTimestamp(block.timestamp);
+    }
+
+    function getCurrentEpoch()
+        virtual override
+        public view
+        returns (uint256)
+    {
+        // solhint-disable not-rely-on-time
+        return WitnetV2.epochFromTimestamp(block.timestamp);
     }
 
     function getLastBeacon()
         virtual override
         external view
         returns (WitnetV2.Beacon memory _beacon)
     {
-        return __blocks().lastBeacon;
+        return __blocks().beacons[__blocks().lastBeaconIndex];
     }
 
-    function getLastBeaconIndex()
+    function getLastBeaconEpoch()
         virtual override
-        external view 
+        external view
         returns (uint256)
     {
-        return __blocks().lastBeacon.index;
+        return getLastBeaconIndex() * 10;
     }
 
-    function getCurrentBeaconIndex()
+    function getLastBeaconIndex()
         virtual override
-        public view
+        public view 
         returns (uint256)
     {
-        // solhint-disable not-rely-on-time
-        return WitnetV2.beaconIndexFromTimestamp(block.timestamp);
+        return __blocks().lastBeaconIndex;
     }
 
     function getNextBeaconIndex()
         virtual override
-        external view
-        returns (uint256) 
+        external view 
+        returns (uint256)
+    {
+        return __blocks().nextBeaconIndex;
+    }
+
+    function __insertBeaconSuccessor(uint nextBeaconIndex, uint tallyBeaconIndex)
+        virtual internal
+        returns (uint256)
+    {
+        uint _currentSuccessor = __blocks().beaconSuccessorOf[nextBeaconIndex];
+        if (_currentSuccessor == 0) {
+            __blocks().beaconSuccessorOf[nextBeaconIndex] = tallyBeaconIndex;
+            return tallyBeaconIndex;
+        } else if (_currentSuccessor >= tallyBeaconIndex) {
+            __blocks().beaconSuccessorOf[tallyBeaconIndex] = _currentSuccessor;
+            return tallyBeaconIndex;
+        } else {
+            return __insertBeaconSuccessor(_currentSuccessor, tallyBeaconIndex);
+        }
+    }
+
+    function disputeQuery(bytes32 queryHash, uint256 tallyBeaconIndex)
+        virtual override
+        external 
+    {
+        require(
+            msg.sender == address(board), 
+            "WitnetBlocksDefault: unauthorized"
+        );
+        if (tallyBeaconIndex > __blocks().lastBeaconIndex) {
+            if (__blocks().nextBeaconIndex > __blocks().lastBeaconIndex) {
+                // pending rollup
+                if (tallyBeaconIndex < __blocks().nextBeaconIndex) {
+                    __blocks().beaconSuccessorOf[tallyBeaconIndex] = __blocks().nextBeaconIndex;
+                    __blocks().nextBeaconIndex = tallyBeaconIndex;
+                } else if (tallyBeaconIndex > __blocks().nextBeaconIndex) {
+                    __blocks().nextBeaconIndex = __insertBeaconSuccessor(__blocks().nextBeaconIndex, tallyBeaconIndex);
+                    if (tallyBeaconIndex > __blocks().latestBeaconIndex) {
+                        __blocks().latestBeaconIndex = tallyBeaconIndex;
+                    }
+                }
+            } else {
+                // settle next rollup
+                __blocks().nextBeaconIndex = tallyBeaconIndex;
+                __blocks().latestBeaconIndex = tallyBeaconIndex;
+            }
+            BeaconTracks storage __tracks = __tracks_(tallyBeaconIndex);
+            if (!__tracks.disputed[queryHash]) {
+                __tracks.disputed[queryHash] = true;
+                __tracks.queries.push(queryHash);
+            }
+        } else {
+            revert("WitnetBlocksDefault: too late dispute");
+        }
+    }
+
+    function rollupTallyHashes(
+            WitnetV2.FastForward[] calldata ffs,
+            bytes32[] calldata tallyHashes,
+            uint256 tallyOffset,
+            uint256 tallyLength
+        )
+        external 
+        // TODO: modifiers
+        returns (uint256 weiReward)
     {
-        return getCurrentBeaconIndex() + 1;
+        uint _nextBeaconIndex = __blocks().nextBeaconIndex;
+        uint _lastBeaconIndex = __blocks().lastBeaconIndex;
+        require(
+            ffs.length >= 1
+                && ffs[ffs.length - 1].next.index <= _nextBeaconIndex,
+            "WitnetBlocksDefault: misleading rollup"
+        );
+        if (_nextBeaconIndex > _lastBeaconIndex) {
+            WitnetV2.Beacon memory _lastBeacon = __blocks().beacons[_lastBeaconIndex];
+            for (uint _ix = 0; _ix < ffs.length; _ix ++) {
+                _lastBeacon = _lastBeacon.verifyFastForward(ffs[_ix ++]);
+            }
+            emit FastForward(
+                msg.sender, 
+                _lastBeacon.index, 
+                _lastBeaconIndex
+            );
+            {
+                __blocks().beaconSuccessorOf[_lastBeaconIndex] = _lastBeacon.index;
+                _lastBeaconIndex = _lastBeacon.index;
+                __blocks().lastBeaconIndex = _lastBeaconIndex;
+                __blocks().beacons[_lastBeaconIndex] = _lastBeacon;
+            }
+        }
+        if (_nextBeaconIndex == _lastBeaconIndex) {
+            BeaconTracks storage __tracks = __tracks_(_nextBeaconIndex);
+            require(
+                tallyOffset == __tracks.offset
+                    && tallyOffset + tallyLength == tallyHashes.length,
+                "WitnetBlocksDefault: out of range"
+            );
+            require(
+                WitnetV2.merkle(tallyHashes) == __blocks().beacons[_nextBeaconIndex].ddrTallyRoot,
+                "WitnetBlocksDefault: invalid tallies"
+            );
+            uint _maxTallyOffset = tallyOffset + tallyLength;
+            for (; tallyOffset < _maxTallyOffset; tallyOffset ++) {
+                (bytes32 _queryHash, uint256 _queryStakes) = board.determineQueryTallyHash(tallyHashes[tallyOffset]);
+                require(
+                    __tracks.disputed[_queryHash],
+                    "WitnetBlocksDefault: already judged"
+                );
+                __tracks.disputed[_queryHash] = false;
+                weiReward += _queryStakes;
+            }
+            if (tallyOffset == tallyHashes.length) {
+                __blocks().nextBeaconIndex = __blocks().beaconSuccessorOf[_nextBeaconIndex];
+            } else {
+                __tracks.offset = tallyOffset;
+            }
+            emit Rollup(msg.sender, _nextBeaconIndex, tallyOffset, weiReward);
+        } else {
+            revert("WitnetBlocksDefault: no pending rollup");
+        }
     }
-}
+}