Skip to content

Commit 3c59942

Browse files
rach-idrach-id
committed
feat!: use a struct for namespace and rename namespaceID
1 parent d58f72d commit 3c59942

10 files changed

+188
-150
lines changed

‎src/lib/tree/Constants.sol

+9-3
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,13 @@ library Constants {
1515
bytes1 internal constant LEAF_PREFIX = 0x00;
1616
bytes1 internal constant NODE_PREFIX = 0x01;
1717

18-
/// @dev Parity share namespace ID
19-
NamespaceID internal constant PARITY_SHARE_NAMESPACE_ID =
20-
NamespaceID.wrap(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
18+
/// @dev Parity share namespace in bytes.
19+
bytes29 internal constant PARITY_SHARE_NAMESPACE_BYTES =
20+
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
21+
}
22+
23+
/// @dev Parity share namespace.
24+
/// utility function to provide the parity share namespace as a Namespace struct.
25+
function PARITY_SHARE_NAMESPACE() pure returns (Namespace memory) {
26+
return Namespace(0xFF, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
2127
}

‎src/lib/tree/Types.sol

+27-10
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,37 @@
11
// SPDX-License-Identifier: Apache-2.0
22
pragma solidity ^0.8.19;
33

4-
type NamespaceID is bytes29;
4+
/// @notice A representation of the Celestia-app namespace ID and its version.
5+
/// More in here: https://github.com/celestiaorg/celestia-app/blob/main/docs/architecture/adr-014-versioned-namespaces.md
6+
struct Namespace {
7+
// The namespace version.
8+
bytes1 version;
9+
// The namespace ID.
10+
bytes28 id;
11+
}
12+
13+
using {equalTo, lessThan, greaterThan, toBytes} for Namespace global;
514

6-
using {equality as ==} for NamespaceID global;
7-
using {lessthan as <} for NamespaceID global;
8-
using {greaterthan as >} for NamespaceID global;
15+
function equalTo(Namespace memory l, Namespace memory r) pure returns (bool) {
16+
return l.toBytes() == r.toBytes();
17+
}
18+
19+
function lessThan(Namespace memory l, Namespace memory r) pure returns (bool) {
20+
return l.toBytes() < r.toBytes();
21+
}
922

10-
function equality(NamespaceID l, NamespaceID r) pure returns (bool) {
11-
return NamespaceID.unwrap(l) == NamespaceID.unwrap(r);
23+
function greaterThan(Namespace memory l, Namespace memory r) pure returns (bool) {
24+
return l.toBytes() > r.toBytes();
1225
}
1326

14-
function lessthan(NamespaceID l, NamespaceID r) pure returns (bool) {
15-
return NamespaceID.unwrap(l) < NamespaceID.unwrap(r);
27+
function toBytes(Namespace memory n) pure returns (bytes29) {
28+
return bytes29(abi.encodePacked(n.version, n.id));
1629
}
1730

18-
function greaterthan(NamespaceID l, NamespaceID r) pure returns (bool) {
19-
return NamespaceID.unwrap(l) > NamespaceID.unwrap(r);
31+
function toNamespace(bytes29 n) pure returns (Namespace memory) {
32+
bytes memory id = new bytes(28);
33+
for (uint256 i = 1; i < 29; i++) {
34+
id[i - 1] = n[i];
35+
}
36+
return Namespace(n[0], bytes28(id));
2037
}

‎src/lib/tree/namespace/NamespaceMerkleTree.sol

+7-7
Original file line numberDiff line numberDiff line change
@@ -14,18 +14,18 @@ library NamespaceMerkleTree {
1414
/// @notice Verify if element exists in Merkle tree, given data, proof, and root.
1515
/// @param root The root of the tree in which the given leaf is verified.
1616
/// @param proof Namespace Merkle proof for the leaf.
17-
/// @param minmaxNID Namespace ID of the leaf.
17+
/// @param namespace Namespace of the leaf.
1818
/// @param data The data of the leaf to verify.
1919
/// @return `true` if the proof is valid, `false` otherwise.
2020
/// @dev proof.numLeaves is necessary to determine height of subtree containing the data to prove.
2121
function verify(
2222
NamespaceNode memory root,
2323
NamespaceMerkleProof memory proof,
24-
NamespaceID minmaxNID,
24+
Namespace memory namespace,
2525
bytes memory data
2626
) internal pure returns (bool) {
2727
// A sibling at height 1 is created by getting the leafDigest of the original data.
28-
NamespaceNode memory node = leafDigest(minmaxNID, data);
28+
NamespaceNode memory node = leafDigest(namespace, data);
2929

3030
// Since we're verifying a leaf, height parameter is 1.
3131
return verifyInner(root, proof, node, 1);
@@ -137,19 +137,19 @@ library NamespaceMerkleTree {
137137
/// @notice Verify if contiguous elements exists in Merkle tree, given leaves, mutliproof, and root.
138138
/// @param root The root of the tree in which the given leaves are verified.
139139
/// @param proof Namespace Merkle multiproof for the leaves.
140-
/// @param minmaxNID Namespace ID of the leaves. All leaves must have the same namespace ID.
141-
/// @param data The leaves to verify. Note: leaf data must be the _entire_ share (including namespace ID prefixing).
140+
/// @param namespace Namespace of the leaves. All leaves must have the same namespace.
141+
/// @param data The leaves to verify. Note: leaf data must be the _entire_ share (including namespace prefixing).
142142
/// @return `true` if the proof is valid, `false` otherwise.
143143
function verifyMulti(
144144
NamespaceNode memory root,
145145
NamespaceMerkleMultiproof memory proof,
146-
NamespaceID minmaxNID,
146+
Namespace memory namespace,
147147
bytes[] memory data
148148
) internal pure returns (bool) {
149149
// Hash all the leaves to get leaf nodes.
150150
NamespaceNode[] memory nodes = new NamespaceNode[](data.length);
151151
for (uint256 i = 0; i < data.length; ++i) {
152-
nodes[i] = leafDigest(minmaxNID, data[i]);
152+
nodes[i] = leafDigest(namespace, data[i]);
153153
}
154154

155155
// Verify inclusion of leaf nodes.

‎src/lib/tree/namespace/NamespaceNode.sol

+5-5
Original file line numberDiff line numberDiff line change
@@ -5,10 +5,10 @@ import "../Types.sol";
55

66
/// @notice Namespace Merkle Tree node.
77
struct NamespaceNode {
8-
// Minimum namespace ID.
9-
NamespaceID min;
10-
// Maximum namespace ID.
11-
NamespaceID max;
8+
// Minimum namespace.
9+
Namespace min;
10+
// Maximum namespace.
11+
Namespace max;
1212
// Node value.
1313
bytes32 digest;
1414
}
@@ -19,5 +19,5 @@ struct NamespaceNode {
1919
/// @return `true` is equal, `false otherwise.
2020
// solhint-disable-next-line func-visibility
2121
function namespaceNodeEquals(NamespaceNode memory first, NamespaceNode memory second) pure returns (bool) {
22-
return (first.min == second.min) && (first.max == second.max) && (first.digest == second.digest);
22+
return first.min.equalTo(second.min) && first.max.equalTo(second.max) && (first.digest == second.digest);
2323
}

‎src/lib/tree/namespace/TreeHasher.sol

+24-14
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,8 @@ import "./NamespaceNode.sol";
77

88
/// @notice Get the minimum namespace.
99
// solhint-disable-next-line func-visibility
10-
function namespaceMin(NamespaceID l, NamespaceID r) pure returns (NamespaceID) {
11-
if (l < r) {
10+
function namespaceMin(Namespace memory l, Namespace memory r) pure returns (Namespace memory) {
11+
if (l.lessThan(r)) {
1212
return l;
1313
} else {
1414
return r;
@@ -17,22 +17,22 @@ function namespaceMin(NamespaceID l, NamespaceID r) pure returns (NamespaceID) {
1717

1818
/// @notice Get the maximum namespace.
1919
// solhint-disable-next-line func-visibility
20-
function namespaceMax(NamespaceID l, NamespaceID r) pure returns (NamespaceID) {
21-
if (l > r) {
20+
function namespaceMax(Namespace memory l, Namespace memory r) pure returns (Namespace memory) {
21+
if (l.greaterThan(r)) {
2222
return l;
2323
} else {
2424
return r;
2525
}
2626
}
2727

2828
/// @notice Hash a leaf node.
29-
/// @param minmaxNID Namespace ID.
29+
/// @param namespace Namespace of the leaf.
3030
/// @param data Raw data of the leaf.
3131
/// @dev More details in https://github.com/celestiaorg/celestia-specs/blob/master/src/specs/data_structures.md#namespace-merkle-tree
3232
// solhint-disable-next-line func-visibility
33-
function leafDigest(NamespaceID minmaxNID, bytes memory data) pure returns (NamespaceNode memory) {
34-
bytes32 digest = sha256(abi.encodePacked(Constants.LEAF_PREFIX, minmaxNID, data));
35-
NamespaceNode memory node = NamespaceNode(minmaxNID, minmaxNID, digest);
33+
function leafDigest(Namespace memory namespace, bytes memory data) pure returns (NamespaceNode memory) {
34+
bytes32 digest = sha256(abi.encodePacked(Constants.LEAF_PREFIX, namespace.toBytes(), data));
35+
NamespaceNode memory node = NamespaceNode(namespace, namespace, digest);
3636
return node;
3737
}
3838

@@ -42,17 +42,27 @@ function leafDigest(NamespaceID minmaxNID, bytes memory data) pure returns (Name
4242
/// @dev More details in https://github.com/celestiaorg/celestia-specs/blob/master/src/specs/data_structures.md#namespace-merkle-tree
4343
// solhint-disable-next-line func-visibility
4444
function nodeDigest(NamespaceNode memory l, NamespaceNode memory r) pure returns (NamespaceNode memory) {
45-
NamespaceID min = namespaceMin(l.min, r.min);
46-
NamespaceID max;
47-
if (l.min == Constants.PARITY_SHARE_NAMESPACE_ID) {
48-
max = Constants.PARITY_SHARE_NAMESPACE_ID;
49-
} else if (r.min == Constants.PARITY_SHARE_NAMESPACE_ID) {
45+
Namespace memory min = namespaceMin(l.min, r.min);
46+
Namespace memory max;
47+
if (l.min.equalTo(PARITY_SHARE_NAMESPACE())) {
48+
max = PARITY_SHARE_NAMESPACE();
49+
} else if (r.min.equalTo(PARITY_SHARE_NAMESPACE())) {
5050
max = l.max;
5151
} else {
5252
max = namespaceMax(l.max, r.max);
5353
}
5454

55-
bytes32 digest = sha256(abi.encodePacked(Constants.NODE_PREFIX, l.min, l.max, l.digest, r.min, r.max, r.digest));
55+
bytes32 digest = sha256(
56+
abi.encodePacked(
57+
Constants.NODE_PREFIX,
58+
l.min.toBytes(),
59+
l.max.toBytes(),
60+
l.digest,
61+
r.min.toBytes(),
62+
r.max.toBytes(),
63+
r.digest
64+
)
65+
);
5666

5767
NamespaceNode memory node = NamespaceNode(min, max, digest);
5868
return node;

‎src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol

+12-12
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ import "../NamespaceMerkleTree.sol";
1111
/**
1212
* TEST VECTORS
1313
*
14-
* Data blocks: namespace id, data
14+
* Data blocks: namespace, data
1515
* 0x0000000000000000000000000000000000000000000000000000000010 0x01
1616
* 0x0000000000000000000000000000000000000000000000000000000010 0x02
1717
* 0x0000000000000000000000000000000000000000000000000000000010 0x03
@@ -50,33 +50,33 @@ contract NamespaceMerkleMultiproofTest is DSTest {
5050
function setUp() external {}
5151

5252
function assertEqNamespaceNode(NamespaceNode memory first, NamespaceNode memory second) internal {
53-
assertEq(NamespaceID.unwrap(first.min), NamespaceID.unwrap(second.min));
54-
assertEq(NamespaceID.unwrap(first.max), NamespaceID.unwrap(second.max));
53+
assertTrue(first.min.equalTo(second.min));
54+
assertTrue(first.max.equalTo(second.max));
5555
assertEq(first.digest, second.digest);
5656
}
5757

5858
/// @notice Verify inclusion of leaves 0 and 1.
5959
function testVerifyMulti01() external {
60-
NamespaceID nid = NamespaceID.wrap(0x0000000000000000000000000000000000000000000000000000000010);
60+
Namespace memory nid = Namespace(0x00, 0x00000000000000000000000000000000000000000000000000000010);
6161
NamespaceNode memory root = NamespaceNode(
62-
NamespaceID.wrap(0x0000000000000000000000000000000000000000000000000000000010),
63-
NamespaceID.wrap(0x0000000000000000000000000000000000000000000000000000000010),
62+
Namespace(0x00, 0x00000000000000000000000000000000000000000000000000000010),
63+
Namespace(0x00, 0x00000000000000000000000000000000000000000000000000000010),
6464
0x5b3328b03a538d627db78668034089cb395f63d05b24fdf99558d36fe991d268
6565
);
6666
NamespaceNode[] memory sideNodes = new NamespaceNode[](3);
6767
sideNodes[0] = NamespaceNode(
68-
NamespaceID.wrap(0x0000000000000000000000000000000000000000000000000000000010),
69-
NamespaceID.wrap(0x0000000000000000000000000000000000000000000000000000000010),
68+
Namespace(0x00, 0x00000000000000000000000000000000000000000000000000000010),
69+
Namespace(0x00, 0x00000000000000000000000000000000000000000000000000000010),
7070
0xfdb4e3c872666aa9869a1d46c8a5a0e735becdf17c62b9c3ccf4258449475bda
7171
);
7272
sideNodes[1] = NamespaceNode(
73-
NamespaceID.wrap(0x0000000000000000000000000000000000000000000000000000000010),
74-
NamespaceID.wrap(0x0000000000000000000000000000000000000000000000000000000010),
73+
Namespace(0x00, 0x00000000000000000000000000000000000000000000000000000010),
74+
Namespace(0x00, 0x00000000000000000000000000000000000000000000000000000010),
7575
0xc350aeddd5ada629057034f15d4545065213a7a28f9f9b77bdc71c4225145920
7676
);
7777
sideNodes[2] = NamespaceNode(
78-
Constants.PARITY_SHARE_NAMESPACE_ID,
79-
Constants.PARITY_SHARE_NAMESPACE_ID,
78+
PARITY_SHARE_NAMESPACE(),
79+
PARITY_SHARE_NAMESPACE(),
8080
0x5aa3e7ea31995fdd38f41015275229b290a8ee4810521db766ad457b9a8373d6
8181
);
8282

0 commit comments

Comments
 (0)