use index for cid most places

Author: turbocrime

src/CborDecode.sol

@@ -29,8 +29,9 @@ uint8 constant MajMap = 5;
 uint8 constant MajTag = 6;
 uint8 constant MajOther = 7;
 
-uint8 constant True_Type = 21;
 uint8 constant False_Type = 20;
+uint8 constant True_Type = 21;
+uint8 constant Null_Type = 22;
 
 /// @notice This library is a set a functions that allows anyone to decode cbor encoded bytes
 /// @dev methods in this library try to read the data type indicated from cbor encoded data stored in bytes at a specific index
@@ -41,7 +42,7 @@ library CBORDecoder {
     /// @param cborData cbor encoded bytes to parse from
     /// @param byteIdx current position to read on the cbor encoded bytes
     function isNullNext(bytes memory cborData, uint byteIdx) internal pure returns (bool) {
-        return cborData[byteIdx] == hex"f6";
+        return cborData[byteIdx] == hex"f6"; // MajSimple 0xe0 & Null_Type 0x16 == 0xf6
     }
 
     /// @notice attempt to read a bool value

src/CidCbor.sol

@@ -1,80 +1,85 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.28;
 
+import {console} from "forge-std/Test.sol";
 import "./CborDecode.sol";
 import "./Compare.sol";
 
 library CidCbor {
     using CBORDecoder for bytes;
 
+    uint8 private constant MAJOR_BYTE_STRING = 2;
     uint8 private constant MAJOR_TYPE_TAG = 6;
     uint8 private constant TAG_CID = 42;
 
+    uint8 private constant EXPECTED_CID_LENGTH = 37;
+
     uint8 private constant MULTIBASE_FORMAT = 0x00;
     uint8 private constant CID_V1 = 0x01;
     uint8 private constant MULTICODEC_DAG_CBOR = 0x71;
     uint8 private constant MULTIHASH_SHA_256 = 0x12;
     uint8 private constant MULTIHASH_SIZE_32 = 0x20;
 
-    struct Cid {
-        bytes4 prefix;
-        bytes32 sha;
-        bool nullish;
-    }
+    /**
+     * will only encounter Cid v1 dag-cbor sha256, so we can refer to cid within
+     * a larger bytestring by index of its sha256 hash segment. the caller is
+     * responsible for indexing the correct bytestring when retrieving the hash.
+     * due to cbor and cid formats, the hash segment will never index at 0, so
+     * so 0 is used to indicate a null value.
+     */
+    type CidIndex is uint;
 
-    function cidMatches(Cid memory one, Cid memory other) internal pure returns (bool) {
-        require(!(one.nullish && other.nullish), "two nullish cids should not be compared");
-        return Compare.bytesMatch(
-            abi.encodePacked(one.prefix, one.sha, one.nullish), abi.encodePacked(other.prefix, other.sha, other.nullish)
-        );
-    }
+    /**
+     * we will only encounter Cid v1 dag-cbor sha256, so the hash is bytes32
+     */
+    type CidBytes32 is bytes32;
 
     function expectCidTag(bytes memory cborData, uint byteIdx) internal pure returns (uint) {
+        console.log("expectCidTag", byteIdx);
         uint8 maj;
         uint value;
         (maj, value, byteIdx) = cborData.parseCborHeader(byteIdx);
-        require(maj == MAJOR_TYPE_TAG, "expected major type tag");
-        require(value == TAG_CID, "expected tag for CID");
+        require(maj == MAJOR_TYPE_TAG, "expected tag major");
+        require(value == TAG_CID, "expected tag 42 for CID");
         return byteIdx;
     }
 
-    function readCid(bytes memory cborData, uint byteIdx) internal pure returns (Cid memory, uint) {
-        bool nullish = false;
-
-        if (cborData.isNullNext(byteIdx)) {
-            nullish = true;
-            return (Cid(bytes4(0), bytes32(0), nullish), byteIdx + 1);
+    function readCidBytes32(bytes memory cborData, CidIndex idx) internal pure returns (CidBytes32) {
+        uint cidIdx = CidIndex.unwrap(idx);
+        require(cidIdx != 0, "Can't read a CID hash at index 0");
+        bytes memory cidBytes = new bytes(MULTIHASH_SIZE_32);
+        for (uint i = 0; i < MULTIHASH_SIZE_32; i++) {
+            cidBytes[i] = cborData[cidIdx + i];
         }
+        return CidBytes32.wrap(bytes32(cidBytes));
+    }
 
-        (byteIdx) = CidCbor.expectCidTag(cborData, byteIdx);
-
+    function readNullableCidIndex(bytes memory cborData, uint byteIdx) internal pure returns (CidIndex, uint) {
+        console.log("readNullableCid", byteIdx);
         if (cborData.isNullNext(byteIdx)) {
-            nullish = true;
-            return (Cid(bytes4(0), bytes32(0), nullish), byteIdx + 1);
+            console.log("nullish %s, advancing %s + 1", uint8(cborData[byteIdx]), byteIdx);
+            return (CidIndex.wrap(0), byteIdx + 1);
         }
+        console.log("not nullish %s, not advancing %s", uint8(cborData[byteIdx]), byteIdx);
 
-        bytes memory cidBytes;
-        (cidBytes, byteIdx) = cborData.readBytes(byteIdx);
-
-        // multibase format
-        require(uint8(cidBytes[0]) == MULTIBASE_FORMAT, "expected multibase item");
-
-        // cid prefix
-        require(uint8(cidBytes[1]) == CID_V1, "expected CID v1");
-        require(uint8(cidBytes[2]) == MULTICODEC_DAG_CBOR, "expected CID multicodec DAG-CBOR");
-        require(uint8(cidBytes[3]) == MULTIHASH_SHA_256, "expected CID multihash sha-256");
-        require(uint8(cidBytes[4]) == MULTIHASH_SIZE_32, "expected CID content size 32 bytes");
-
-        bytes4 prefix = bytes4(abi.encodePacked(cidBytes[1], cidBytes[2], cidBytes[3], cidBytes[4]));
+        return readCidIndex(cborData, byteIdx);
+    }
 
-        // cid data length plus prefix length
-        require(cidBytes.length == 1 + 4 + MULTIHASH_SIZE_32, "expected cid data to be 37 bytes");
+    function readCidIndex(bytes memory cborData, uint byteIdx) internal pure returns (CidIndex, uint) {
+        (byteIdx) = expectCidTag(cborData, byteIdx);
+        (uint8 maj, uint len, uint bytesStart) = cborData.parseCborHeader(byteIdx);
 
-        bytes memory sha = new bytes(32);
-        for (uint i = 0; i < 32; i++) {
-            sha[i] = cidBytes[5 + i];
-        }
+        require(maj == MAJOR_BYTE_STRING, "expected byte string");
+        require(len == EXPECTED_CID_LENGTH, "expected bytes length 37 for CID");
 
-        return (Cid(prefix, bytes32(sha), nullish), byteIdx);
+        // multibase format
+        require(uint8(cborData[bytesStart]) == MULTIBASE_FORMAT, "expected multibase item");
+        // cid format
+        require(uint8(cborData[bytesStart + 1]) == CID_V1, "expected CID v1");
+        require(uint8(cborData[bytesStart + 2]) == MULTICODEC_DAG_CBOR, "expected CID multicodec DAG-CBOR");
+        require(uint8(cborData[bytesStart + 3]) == MULTIHASH_SHA_256, "expected CID multihash sha-256");
+        require(uint8(cborData[bytesStart + 4]) == MULTIHASH_SIZE_32, "expected CID content size 32 bytes");
+
+        return (CidIndex.wrap(bytesStart + 5), bytesStart + len);
     }
 }

src/CommitCbor.sol

@@ -12,9 +12,9 @@ library CommitCbor {
     struct Commit {
         string did;
         uint8 version;
-        CidCbor.Cid data;
+        CidCbor.CidIndex data;
         string rev;
-        CidCbor.Cid prev;
+        CidCbor.CidIndex prev;
     }
 
     function readCommit(bytes memory cborData, uint byteIdx) internal pure returns (Commit memory ret, uint) {
@@ -33,11 +33,13 @@ library CommitCbor {
                 (ret.version, byteIdx) = cborData.readUInt8(byteIdx);
                 require(ret.version == COMMIT_VERSION, "unexpected commit version");
             } else if (Compare.stringsMatch(mapKey, "data")) {
-                (ret.data, byteIdx) = CidCbor.readCid(cborData, byteIdx);
+                console.log("data", byteIdx);
+                (ret.data, byteIdx) = CidCbor.readCidIndex(cborData, byteIdx);
             } else if (Compare.stringsMatch(mapKey, "rev")) {
                 (ret.rev, byteIdx) = cborData.readString(byteIdx);
             } else if (Compare.stringsMatch(mapKey, "prev")) {
-                (ret.prev, byteIdx) = CidCbor.readCid(cborData, byteIdx);
+                console.log("prev", byteIdx);
+                (ret.prev, byteIdx) = CidCbor.readNullableCidIndex(cborData, byteIdx);
             }
         }
 

src/TreeCbor.sol

@@ -15,10 +15,10 @@ library TreeCbor {
     uint8 private constant MULTIHASH_SIZE_32 = 0x20;
 
     struct Tree {
-        CidCbor.Cid root;
+        CidCbor.CidBytes32 root;
         TreeNodeCbor.TreeNode[] nodes;
         RecordCbor.Record[] records;
-        CidCbor.Cid[] cids;
+        CidCbor.CidBytes32[] cids;
         bool[] nodeOrRecord;
     }
 
@@ -30,18 +30,14 @@ library TreeCbor {
         return len == 2;
     }
 
-    function readTree(bytes[] memory cborData, CidCbor.Cid memory root) internal pure returns (Tree memory) {
+    function readTree(bytes[] memory cborData, CidCbor.CidBytes32 root) internal pure returns (Tree memory) {
         TreeNodeCbor.TreeNode[] memory nodes = new TreeNodeCbor.TreeNode[](cborData.length);
         RecordCbor.Record[] memory records = new RecordCbor.Record[](cborData.length);
-        CidCbor.Cid[] memory cids = new CidCbor.Cid[](cborData.length);
+        CidCbor.CidBytes32[] memory cids = new CidCbor.CidBytes32[](cborData.length);
         bool[] memory nodeOrRecord = new bool[](cborData.length);
 
         for (uint i = 0; i < cborData.length; i++) {
-            cids[i] = CidCbor.Cid(
-                bytes4(abi.encodePacked(CID_V1, MULTICODEC_DAG_CBOR, MULTIHASH_SHA_256, MULTIHASH_SIZE_32)),
-                sha256(cborData[i]),
-                false
-            );
+            cids[i] = CidCbor.CidBytes32.wrap(sha256(cborData[i]));
             uint byteIdx;
             if (itemIsNode(cborData[i])) {
                 (nodes[i], byteIdx) = TreeNodeCbor.readTreeNode(cborData[i], 0);
@@ -56,43 +52,46 @@ library TreeCbor {
         return requireUniqueCidsAndRoot(Tree(root, nodes, records, cids, nodeOrRecord));
     }
 
-    function nodeByCid(Tree memory tree, CidCbor.Cid memory indexCid)
+    function nodeByCid(Tree memory tree, CidCbor.CidBytes32 indexCid)
         internal
         pure
         returns (TreeNodeCbor.TreeNode memory, uint index)
     {
         return nodeByCid(tree, indexCid, 0);
     }
 
-    function nodeByCid(Tree memory tree, CidCbor.Cid memory indexCid, uint startIdx)
+    function nodeByCid(Tree memory tree, CidCbor.CidBytes32 indexCid, uint startIdx)
         internal
         pure
         returns (TreeNodeCbor.TreeNode memory, uint index)
     {
+        bytes32 indexBytes = CidCbor.CidBytes32.unwrap(indexCid);
         for (uint i = startIdx; i < tree.cids.length; i++) {
-            if (CidCbor.cidMatches(tree.cids[i], indexCid)) {
+            if (CidCbor.CidBytes32.unwrap(tree.cids[i]) == indexBytes) {
                 require(tree.nodeOrRecord[i], "expected node");
                 return (tree.nodes[i], i);
             }
         }
         revert("node not found");
     }
 
-    function recordByCid(Tree memory tree, CidCbor.Cid memory indexCid)
+    function recordByCid(Tree memory tree, CidCbor.CidBytes32 indexCid)
         internal
         pure
         returns (RecordCbor.Record memory, uint index)
     {
         return recordByCid(tree, indexCid, 0);
     }
 
-    function recordByCid(Tree memory tree, CidCbor.Cid memory indexCid, uint startIdx)
+    function recordByCid(Tree memory tree, CidCbor.CidBytes32 indexCid, uint startIdx)
         internal
         pure
         returns (RecordCbor.Record memory, uint index)
     {
+        bytes32 indexBytes = CidCbor.CidBytes32.unwrap(indexCid);
+
         for (uint i = startIdx; i < tree.cids.length; i++) {
-            if (CidCbor.cidMatches(tree.cids[i], indexCid)) {
+            if (CidCbor.CidBytes32.unwrap(tree.cids[i]) == indexBytes) {
                 require(!tree.nodeOrRecord[i], "expected record");
                 return (tree.records[i], i);
             }
@@ -102,12 +101,15 @@ library TreeCbor {
 
     function requireUniqueCidsAndRoot(Tree memory tree) internal pure returns (Tree memory) {
         bool rootIncluded;
+        bytes32 treeRoot = CidCbor.CidBytes32.unwrap(tree.root);
         for (uint i = 0; i < tree.cids.length; i++) {
+            bytes32 thisCid = CidCbor.CidBytes32.unwrap(tree.cids[i]);
             if (!rootIncluded) {
-                rootIncluded = CidCbor.cidMatches(tree.cids[i], tree.root);
+                rootIncluded = thisCid == treeRoot;
             }
             for (uint j = i + 1; j < tree.nodes.length; j++) {
-                require(!CidCbor.cidMatches(tree.cids[i], tree.cids[j]), "node cids must be unique");
+                bytes32 otherCid = CidCbor.CidBytes32.unwrap(tree.cids[j]);
+                require(thisCid != otherCid, "node cids must be unique");
             }
         }
         require(rootIncluded, "root cid must be included");

src/TreeNodeCbor.sol

@@ -1,28 +1,29 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.28;
 
+import {console} from "forge-std/Test.sol";
 import "./CidCbor.sol";
 import "./Compare.sol";
 
 library TreeNodeCbor {
     using CBORDecoder for bytes;
 
     struct TreeNode {
-        CidCbor.Cid left;
+        CidCbor.CidIndex left;
         TreeNodeEntry[] entries;
     }
 
     struct TreeNodeEntry {
         string key;
-        CidCbor.Cid value;
-        CidCbor.Cid tree;
+        CidCbor.CidIndex value;
+        CidCbor.CidIndex tree;
     }
 
     struct TreeNodeE {
         uint8 p; // prefixlen
         bytes k; // keysuffix
-        CidCbor.Cid v; // value
-        CidCbor.Cid t; // tree
+        CidCbor.CidIndex v; // value
+        CidCbor.CidIndex t; // tree
     }
 
     function readNodeE(bytes memory cborData, uint byteIdx) internal pure returns (TreeNodeE[] memory ret, uint) {
@@ -45,8 +46,8 @@ library TreeNodeCbor {
 
         uint8 p;
         bytes memory k;
-        CidCbor.Cid memory v;
-        CidCbor.Cid memory t;
+        CidCbor.CidIndex v;
+        CidCbor.CidIndex t;
 
         for (uint i = 0; i < mapLen; i++) {
             string memory mapKey;
@@ -56,9 +57,11 @@ library TreeNodeCbor {
             } else if (Compare.stringsMatch(mapKey, "k")) {
                 (k, byteIdx) = cborData.readBytes(byteIdx);
             } else if (Compare.stringsMatch(mapKey, "t")) {
-                (t, byteIdx) = CidCbor.readCid(cborData, byteIdx);
+                console.log("t");
+                (t, byteIdx) = CidCbor.readNullableCidIndex(cborData, byteIdx);
             } else if (Compare.stringsMatch(mapKey, "v")) {
-                (v, byteIdx) = CidCbor.readCid(cborData, byteIdx);
+                console.log("v");
+                (v, byteIdx) = CidCbor.readNullableCidIndex(cborData, byteIdx);
             }
         }
 
@@ -92,7 +95,8 @@ library TreeNodeCbor {
             string memory mapKey;
             (mapKey, byteIdx) = cborData.readString(byteIdx);
             if (Compare.stringsMatch(mapKey, "l")) {
-                (node.left, byteIdx) = CidCbor.readCid(cborData, byteIdx);
+                console.log("l");
+                (node.left, byteIdx) = CidCbor.readNullableCidIndex(cborData, byteIdx);
             } else if (Compare.stringsMatch(mapKey, "e")) {
                 TreeNodeE[] memory e;
                 (e, byteIdx) = readNodeE(cborData, byteIdx);

test/CborDecode.t.sol

@@ -30,7 +30,6 @@ contract CborDecodeTest {
     using CBORDecoder for bytes;
 
     function test_decodeFixedArray() public pure {
-        // [1,2,3,4,5,6,7,8,9,10,"test", h'01010101', false, null, true]
         bytes memory input = hex"8F0102030405060708090A64746573744401010101F4F6F5";
         uint index = 0;
         uint arrayLen = 0;

test/CidCbor.t.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {Test, console} from "forge-std/Test.sol";
+import "../src/CborDecode.sol";
+import "../src/CidCbor.sol";
+
+contract CidCborTest {
+    bytes private constant cidCbor =
+        hex"D82A5825000171122066DA6655BF8DA79B69A87299CF170FED8497FA3059379DC4A8BFE1E28CAB5D93";
+
+    function test_readCidIndex_only() public pure {
+        CidCbor.readCidIndex(cidCbor, 0);
+    }
+
+    function test_readCidIndex_readCidBytes32() public pure {
+        (CidCbor.CidIndex cidIdx, uint byteIdx) = CidCbor.readCidIndex(cidCbor, 0);
+        require(byteIdx == cidCbor.length, "expected to read all bytes");
+
+        CidCbor.CidBytes32 cid = CidCbor.readCidBytes32(cidCbor, cidIdx);
+        console.logBytes32(CidCbor.CidBytes32.unwrap(cid));
+    }
+}