feat: add build root children from proof

Author: mpolitzer

internal/merkle/builder.go

@@ -4,6 +4,7 @@
 package merkle
 
 import (
+	"errors"
 	"fmt"
 	"math/big"
 	"slices"
@@ -50,6 +51,33 @@ func (proof *Proof) BuildRoot() common.Hash {
 	return rootHash
 }
 
+func (proof *Proof) BuildRootChildren() (common.Hash, common.Hash, error) {
+	if len(proof.Siblings) == 0 {
+		zero := common.Hash{}
+		return zero, zero, errors.New("Siblings array is empty")
+	}
+	two := big.NewInt(2)
+	height := len(proof.Siblings)
+	childHash := proof.Node
+
+	for i, s := range proof.Siblings[:height-1] {
+
+		// ((pos >> i) % 2) == 0
+		if new(big.Int).Rem(new(big.Int).Rsh(proof.Pos, uint(i)), two).Cmp(zero) == 0 {
+			childHash = crypto.Keccak256Hash(childHash[:], s[:])
+		} else {
+			childHash = crypto.Keccak256Hash(s[:], childHash[:])
+		}
+	}
+
+	// ((pos >> (height-1)) % 2) == 0
+	if new(big.Int).Rem(new(big.Int).Rsh(proof.Pos, uint(height-1)), two).Cmp(zero) == 0 {
+		return childHash, proof.Siblings[height-1], nil
+	} else {
+		return proof.Siblings[height-1], childHash, nil
+	}
+}
+
 func (proof *Proof) VerifyRoot(other common.Hash) bool {
 	return proof.BuildRoot() == other
 }
@@ -58,6 +86,15 @@ func (proof *Proof) PushHash(h common.Hash) {
 	proof.Siblings = append(proof.Siblings, h)
 }
 
+func RootChildrenFromProof(leaf common.Hash, siblings []common.Hash, index uint64) (common.Hash, common.Hash, error) {
+	p := &Proof{
+		Pos:      new(big.Int).SetUint64(index),
+		Node:     leaf,
+		Siblings: siblings,
+	}
+	return p.BuildRootChildren()
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // MerkleTree: dave/common-rs/merkle/src/tree.rs

internal/merkle/builder_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -129,6 +130,54 @@ func TestAppendAndRepeated(t *testing.T) {
 	assert.Equal(t, tree1, tree2)
 }
 
+func TestBuildRootChildren1(t *testing.T) {
+	p := Proof{
+		Pos:  big.NewInt(1),
+		Node: common.HexToHash("0x01"),
+		Siblings: []common.Hash{
+			common.HexToHash("0x02"),
+		},
+	}
+	rootHash := p.BuildRoot()
+	lhs, rhs, err := p.BuildRootChildren()
+
+	assert.Nil(t, err)
+	assert.Equal(t, rootHash, crypto.Keccak256Hash(lhs[:], rhs[:]))
+}
+
+func TestBuildRootChildren2(t *testing.T) {
+	p := Proof{
+		Pos:  big.NewInt(1),
+		Node: common.HexToHash("0x01"),
+		Siblings: []common.Hash{
+			common.HexToHash("0x02"),
+			common.HexToHash("0x03"),
+		},
+	}
+	rootHash := p.BuildRoot()
+	lhs, rhs, err := p.BuildRootChildren()
+
+	assert.Nil(t, err)
+	assert.Equal(t, rootHash, crypto.Keccak256Hash(lhs[:], rhs[:]))
+}
+
+func TestBuildRootChildren3(t *testing.T) {
+	p := Proof{
+		Pos:  big.NewInt(1),
+		Node: common.HexToHash("0x01"),
+		Siblings: []common.Hash{
+			common.HexToHash("0x02"),
+			common.HexToHash("0x03"),
+			common.HexToHash("0x04"),
+		},
+	}
+	rootHash := p.BuildRoot()
+	lhs, rhs, err := p.BuildRootChildren()
+
+	assert.Nil(t, err)
+	assert.Equal(t, rootHash, crypto.Keccak256Hash(lhs[:], rhs[:]))
+}
+
 // repanicked
 //func TestBuildNotPow2(t *testing.T) {
 //	defer recover()