Gold-pegged posting fee activates claims and contributes to VS; add oracle submodules

Author: VSP-0

.gitignore

@@ -15,6 +15,19 @@ foundry.lock
 # Node (in case tests/scripts install tooling later)
 node_modules/
 
+# misc
+modules/
+objects/
+
+# Allow tracked submodules
+lib/*
+!lib/
+!lib/chainlink
+!lib/chainlink-brownie-contract
+
 # OS
 .DS_Store
 Thumbs.db
+
+# misc
+audits

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/chainlink"]
+	path = lib/chainlink
+	url = https://github.com/smartcontractkit/chainlink
+[submodule "lib/chainlink-brownie-contracts"]
+	path = lib/chainlink-brownie-contracts
+	url = https://github.com/smartcontractkit/chainlink-brownie-contracts

foundry.toml

@@ -8,7 +8,8 @@ optimizer_runs = 200
 via_ir = true
 
 remappings = [
-    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
+    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
+    "@chainlink/contracts/=lib/chainlink-brownie-contracts/contracts/"
 ]
 
 [rpc_endpoints]

lib/chainlink

@@ -2,15 +2,15 @@
 pragma solidity ^0.8.20;
 
 import "./PostRegistry.sol";
-import "./StakeEngine.sol";
 import "./LinkGraph.sol";
 import "./ScoreEngine.sol";
+import "./interfaces/IStakeEngine.sol";
 
 /// @title ProtocolViews
 /// @notice Read-only aggregation layer for UI/indexers.
 contract ProtocolViews {
     PostRegistry public immutable registry;
-    StakeEngine public immutable stake;
+    IStakeEngine public immutable stake;
     LinkGraph public immutable graph;
     ScoreEngine public immutable score;
 
@@ -31,7 +31,7 @@ contract ProtocolViews {
         address score_
     ) {
         registry = PostRegistry(registry_);
-        stake = StakeEngine(stake_);
+        stake = IStakeEngine(stake_);
         graph = LinkGraph(graph_);
         score = ScoreEngine(score_);
     }

lib/chainlink-brownie-contracts

@@ -3,42 +3,25 @@ pragma solidity ^0.8.20;
 
 import "./PostRegistry.sol";
 import "./LinkGraph.sol";
-import "./StakeEngine.sol";
+import "./interfaces/IStakeEngine.sol";
 
 /// @title ScoreEngine
-/// @notice Computes base and effective Veracity Scores (VS) for claims.
+/// @notice Computes base and effective Verity Scores (VS) for claims.
 ///         VS is represented as signed ray (1e18 = +1.0).
-///
-/// RULES:
-/// - baseVS depends only on direct stake
-/// - effectiveVS propagates recursively over links
-/// - a link contributes ONLY IF:
-///     * IC is economically active (totalStake >= postingFeeThreshold)
-///     * DC is economically active (totalStake >= postingFeeThreshold)
-///     * link itself is economically active (totalStake >= postingFeeThreshold)
-/// - symmetry preserved: negative VS propagates normally
-///
-/// NEW (3.6+ incentive change):
-/// - Incoming effect is NOT just icVS * linkVS.
-/// - Instead, an IC exports its (effectiveVS(IC)) “mass” across ALL of its outgoing links
-///   proportional to each link’s stake (conservation / no amplification):
-///
-///     let S = sum_{outgoing links of IC} totalStake(link)
-///     share(link) = totalStake(link) / S
-///
-///     incomingEffect(link -> DC) = linkVS * icVS * share(link)
-///
-///   (and then flipped if edge.isChallenge, which negates linkVS)
 contract ScoreEngine {
     PostRegistry public immutable registry;
-    StakeEngine public immutable stake;
+    IStakeEngine public immutable stake;
     LinkGraph public immutable graph;
 
     int256 internal constant RAY = 1e18;
 
-    constructor(address registry_, address stake_, address graph_) {
+    constructor(
+        address registry_,
+        address stake_,
+        address graph_
+    ) {
         registry = PostRegistry(registry_);
-        stake = StakeEngine(stake_);
+        stake = IStakeEngine(stake_);
         graph = LinkGraph(graph_);
     }
 
@@ -47,14 +30,20 @@ contract ScoreEngine {
     // ---------------------------------------------------------------------
 
     /// @notice Base VS = (2A / (A + D)) - 1   (ray-scaled)
+    /// @dev Posting fee is injected into A *only when active*
     function baseVSRay(uint256 postId) public view returns (int256) {
         (uint256 A, uint256 D) = stake.getPostTotals(postId);
+        uint256 postingFee = stake.postingFeeThreshold();
+
         uint256 T = A + D;
-        if (T == 0) return 0;
+        if (T < postingFee) return 0;
+
+        // Inject posting fee as virtual support
+        uint256 Aeff = A + postingFee;
+        uint256 Teff = Aeff + D;
 
-        // ray math: ((2A / T) - 1) * 1e18
-        int256 num = int256(2 * A) * RAY;
-        int256 vs = (num / int256(T)) - RAY;
+        int256 num = int256(2 * Aeff) * RAY;
+        int256 vs = (num / int256(Teff)) - RAY;
 
         return _clampRay(vs);
     }
@@ -67,19 +56,17 @@ contract ScoreEngine {
         return _effectiveVSRay(claimPostId, 0);
     }
 
-    function _effectiveVSRay(uint256 claimPostId, uint256 depth) internal view returns (int256) {
-        // recursion safety
+    function _effectiveVSRay(uint256 claimPostId, uint256 depth)
+        internal
+        view
+        returns (int256)
+    {
         if (depth > 32) return 0;
 
-        uint256 threshold = stake.postingFeeThreshold();
+        uint256 postingFee = stake.postingFeeThreshold();
+        if (!_isActive(claimPostId, postingFee)) return 0;
 
-        // DC must be economically active to have meaningful effectiveVS
-        if (!_isActive(claimPostId, threshold)) {
-            return 0;
-        }
-
-        int256 baseVS = baseVSRay(claimPostId);
-        int256 acc = baseVS;
+        int256 acc = baseVSRay(claimPostId);
 
         LinkGraph.IncomingEdge[] memory inc = graph.getIncoming(claimPostId);
 
@@ -89,39 +76,23 @@ contract ScoreEngine {
             uint256 ic = e.fromClaimPostId;
             uint256 linkPostId = e.linkPostId;
 
-            // IC must be economically active
-            if (!_isActive(ic, threshold)) continue;
-
-            // Link post must be economically active
-            if (!_isActive(linkPostId, threshold)) continue;
+            if (!_isActive(ic, postingFee)) continue;
+            if (!_isActive(linkPostId, postingFee)) continue;
 
-            // IC effectiveVS (recursive)
             int256 icVS = _effectiveVSRay(ic, depth + 1);
             if (icVS == 0) continue;
 
-            // Compute sum of ALL outgoing link stakes from IC (distribution denominator)
-            uint256 sumOutgoingLinkStake = _sumOutgoingLinkStake(ic, threshold);
-            if (sumOutgoingLinkStake == 0) continue;
+            uint256 sumOutgoing = _sumOutgoingLinkStake(ic, postingFee);
+            if (sumOutgoing == 0) continue;
 
-            // This particular link stake (numerator)
             uint256 linkStake = _totalStake(linkPostId);
-            if (linkStake == 0) continue;
+            if (linkStake < postingFee) continue;
 
-            // Link "vote" is the link's own VS (based on its own stake queues)
-            // (Links don't have incoming claim-links, so baseVS == effectiveVS for links.)
             int256 linkVS = baseVSRay(linkPostId);
+            if (e.isChallenge) linkVS = -linkVS;
 
-            // challenge edge flips semantic polarity
-            if (e.isChallenge) {
-                linkVS = -linkVS;
-            }
-
-            // incomingEffect = linkVS * icVS * (linkStake / sumOutgoingLinkStake)
-            // Keep ray precision:
-            //   (linkVS * icVS) / RAY  => ray
-            //   then * linkStake / sumOutgoing => ray
             int256 contrib = (linkVS * icVS) / RAY;
-            contrib = (contrib * int256(linkStake)) / int256(sumOutgoingLinkStake);
+            contrib = (contrib * int256(linkStake)) / int256(sumOutgoing);
 
             acc += contrib;
         }
@@ -138,28 +109,23 @@ contract ScoreEngine {
         return s + d;
     }
 
-    function _isActive(uint256 postId, uint256 threshold) internal view returns (bool) {
-        uint256 t = _totalStake(postId);
-        if (threshold == 0) {
-            return t > 0;
-        }
-        return t >= threshold;
+    function _isActive(uint256 postId, uint256 threshold)
+        internal
+        view
+        returns (bool)
+    {
+        return _totalStake(postId) >= threshold;
     }
 
-    /// @dev Sum stakes of ALL outgoing links from IC. (Optional: only count links that are economically active.)
-    function _sumOutgoingLinkStake(uint256 icClaimPostId, uint256 threshold) internal view returns (uint256 sum) {
-        LinkGraph.Edge[] memory outs = graph.getOutgoing(icClaimPostId);
+    function _sumOutgoingLinkStake(uint256 ic, uint256 threshold)
+        internal
+        view
+        returns (uint256 sum)
+    {
+        LinkGraph.Edge[] memory outs = graph.getOutgoing(ic);
         for (uint256 i = 0; i < outs.length; i++) {
-            uint256 linkPostId = outs[i].linkPostId;
-            uint256 t = _totalStake(linkPostId);
-
-            // Only include links that are active; prevents dust from diluting distribution.
-            if (threshold == 0) {
-                if (t == 0) continue;
-            } else {
-                if (t < threshold) continue;
-            }
-
+            uint256 t = _totalStake(outs[i].linkPostId);
+            if (t < threshold) continue;
             sum += t;
         }
     }
@@ -170,3 +136,4 @@ contract ScoreEngine {
         return x;
     }
 }
+