V 3.5

Author: VSP-0

src/PostRegistry.sol

@@ -47,16 +47,19 @@ contract PostRegistry {
 
     error NotOwner();
     error LinkGraphAlreadySet();
+    error LinkGraphZeroAddress();
     error LinkGraphNotSet();
 
     constructor() {
         owner = msg.sender;
     }
 
+    /// @notice One-time wiring to the LinkGraph contract.
+    /// @dev IMPORTANT: LinkGraph.registry must be set separately by LinkGraph.owner via LinkGraph.setRegistry(address(this)).
     function setLinkGraph(address linkGraph_) external {
         if (msg.sender != owner) revert NotOwner();
         if (address(linkGraph) != address(0)) revert LinkGraphAlreadySet();
-        if (linkGraph_ == address(0)) revert LinkGraphNotSet();
+        if (linkGraph_ == address(0)) revert LinkGraphZeroAddress();
 
         linkGraph = LinkGraph(linkGraph_);
         emit LinkGraphSet(linkGraph_);
@@ -96,7 +99,13 @@ contract PostRegistry {
         postId = nextPostId++;
 
         uint256 linkId = links.length;
-        links.push(Link({independentPostId: independentPostId, dependentPostId: dependentPostId, isChallenge: isChallenge}));
+        links.push(
+            Link({
+                independentPostId: independentPostId,
+                dependentPostId: dependentPostId,
+                isChallenge: isChallenge
+            })
+        );
 
         posts[postId] = Post({
             creator: msg.sender,
@@ -105,7 +114,8 @@ contract PostRegistry {
             contentId: linkId
         });
 
-        // 🔐 DAG enforcement + metadata storage
+        // DAG enforcement + metadata storage
+        // NOTE: This will revert NotRegistry() unless LinkGraph.setRegistry(address(this)) has already been called.
         linkGraph.addEdge(independentPostId, dependentPostId, postId, isChallenge);
 
         emit PostCreated(postId, msg.sender, ContentType.Link);
@@ -129,3 +139,4 @@ contract PostRegistry {
         return postId < nextPostId;
     }
 }
+

src/ProtocolViews.sol

@@ -2,23 +2,19 @@
 pragma solidity ^0.8.20;
 
 import "./PostRegistry.sol";
-import "./LinkGraph.sol";
 import "./StakeEngine.sol";
+import "./LinkGraph.sol";
 import "./ScoreEngine.sol";
 
 /// @title ProtocolViews
-/// @notice Read-only aggregation over PostRegistry + StakeEngine + LinkGraph + ScoreEngine.
-///         No storage; no mutation; deterministic output.
+/// @notice Read-only aggregation layer for UI/indexers.
 contract ProtocolViews {
     PostRegistry public immutable registry;
     StakeEngine public immutable stake;
     LinkGraph public immutable graph;
     ScoreEngine public immutable score;
 
     struct ClaimSummary {
-        uint256 postId;
-        address creator;
-        uint256 version;
         string text;
         uint256 supportStake;
         uint256 challengeStake;
@@ -40,107 +36,73 @@ contract ProtocolViews {
         score = ScoreEngine(score_);
     }
 
-    // ------------------------------------------------------------------------
-    // Claim summary
-    // ------------------------------------------------------------------------
-
     function getClaimSummary(uint256 claimPostId)
         external
         view
-        returns (ClaimSummary memory summary)
+        returns (ClaimSummary memory s)
     {
         (
-            address creator,
-            uint256 version,
+            ,
+            ,
             PostRegistry.ContentType ct,
             uint256 contentId
         ) = registry.getPost(claimPostId);
 
-        require(ct == PostRegistry.ContentType.Claim, "ProtocolViews: not claim");
+        require(ct == PostRegistry.ContentType.Claim, "not claim");
 
-        string memory text = registry.getClaim(contentId);
+        s.text = registry.getClaim(contentId);
 
-        (uint256 supportStake, uint256 challengeStake) =
+        (s.supportStake, s.challengeStake) =
             stake.getPostTotals(claimPostId);
 
-        int256 baseVS = score.baseVSRay(claimPostId);
-        int256 effectiveVS = score.effectiveVSRay(claimPostId);
-
-        uint256 incomingCount =
-            graph.getIncoming(claimPostId).length;
-
-        uint256 outgoingCount =
-            graph.getOutgoing(claimPostId).length;
-
-        summary = ClaimSummary({
-            postId: claimPostId,
-            creator: creator,
-            version: version,
-            text: text,
-            supportStake: supportStake,
-            challengeStake: challengeStake,
-            baseVSRay: baseVS,
-            effectiveVSRay: effectiveVS,
-            incomingCount: incomingCount,
-            outgoingCount: outgoingCount
-        });
+        s.baseVSRay = score.baseVSRay(claimPostId);
+        s.effectiveVSRay = score.effectiveVSRay(claimPostId);
+
+        s.incomingCount = graph.getIncoming(claimPostId).length;
+        s.outgoingCount = graph.getOutgoing(claimPostId).length;
     }
 
-    // ------------------------------------------------------------------------
-    // Raw VS passthroughs
-    // ------------------------------------------------------------------------
+    // passthrough helpers
 
-    /// @notice Raw base VS in ray (1e18 = +1.0, -1e18 = -1.0).
     function getBaseVSRay(uint256 claimPostId) external view returns (int256) {
         return score.baseVSRay(claimPostId);
     }
 
-    /// @notice Raw effective VS in ray (multi-hop, symmetrical).
     function getEffectiveVSRay(uint256 claimPostId) external view returns (int256) {
         return score.effectiveVSRay(claimPostId);
     }
 
-    // ------------------------------------------------------------------------
-    // Graph passthroughs
-    // ------------------------------------------------------------------------
-
-    function getOutgoingEdges(uint256 claimPostId)
+    function getIncomingEdges(uint256 claimPostId)
         external
         view
-        returns (LinkGraph.Edge[] memory)
+        returns (LinkGraph.IncomingEdge[] memory)
     {
-        return graph.getOutgoing(claimPostId);
+        return graph.getIncoming(claimPostId);
     }
 
-    function getIncomingEdges(uint256 claimPostId)
+    function getOutgoingEdges(uint256 claimPostId)
         external
         view
-        returns (LinkGraph.IncomingEdge[] memory)
+        returns (LinkGraph.Edge[] memory)
     {
-        return graph.getIncoming(claimPostId);
+        return graph.getOutgoing(claimPostId);
     }
 
-    /// @notice Resolve link metadata for a link post id.
     function getLinkMeta(uint256 linkPostId)
         external
         view
-        returns (
-            uint256 independentClaimPostId,
-            uint256 dependentClaimPostId,
-            bool isChallenge
-        )
+        returns (uint256 from, uint256 to, bool isChallenge)
     {
         (
             ,
             ,
             PostRegistry.ContentType ct,
-            uint256 contentId
+            uint256 linkId
         ) = registry.getPost(linkPostId);
 
-        require(ct == PostRegistry.ContentType.Link, "ProtocolViews: not link");
+        require(ct == PostRegistry.ContentType.Link, "not link");
 
-        (independentClaimPostId, dependentClaimPostId, isChallenge) =
-            registry.getLink(contentId);
+        return registry.getLink(linkId);
     }
 }