Merge pull request #1777 from lightninglabs/wip/supplyverify/pull-sync-verify

supplyverifier: add pull syncer and non-universe node verification

Author: Roasbeef

docs/release-notes/release-notes-0.7.0.md

@@ -73,6 +73,7 @@
    - https://github.com/lightninglabs/taproot-assets/pull/1675
    - https://github.com/lightninglabs/taproot-assets/pull/1674
    - https://github.com/lightninglabs/taproot-assets/pull/1784
+   - https://github.com/lightninglabs/taproot-assets/pull/1777
 
 - A new [address version 2 was introduced that supports grouped assets and
   custom (sender-defined)

itest/supply_commit_test.go

@@ -3,6 +3,7 @@ package itest
 import (
 	"bytes"
 	"context"
+	"strings"
 	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2"
@@ -586,6 +587,60 @@ func testSupplyCommitIgnoreAsset(t *harnessTest) {
 		t.t, rpcAsset.Amount,
 		uniFetchResp.IgnoreSubtreeRoot.RootNode.RootSum,
 	)
+
+	t.Log("Attempting to fetch supply commit from secondary node")
+
+	var peerFetchResp *unirpc.FetchSupplyCommitResponse
+	require.Eventually(t.t, func() bool {
+		// nolint: lll
+		peerFetchResp, err = secondTapd.FetchSupplyCommit(
+			ctxb, &unirpc.FetchSupplyCommitRequest{
+				GroupKey: &unirpc.FetchSupplyCommitRequest_GroupKeyBytes{
+					GroupKeyBytes: groupKeyBytes,
+				},
+				Locator: &unirpc.FetchSupplyCommitRequest_VeryFirst{
+					VeryFirst: true,
+				},
+			},
+		)
+		if err != nil &&
+			strings.Contains(err.Error(), "commitment not found") {
+
+			return false
+		}
+		require.NoError(t.t, err)
+
+		// If the fetch response has no block height or hash,
+		// it means that the supply commitment transaction has not
+		// been mined yet, so we should retry.
+		if peerFetchResp.ChainData.BlockHeight == 0 ||
+			len(peerFetchResp.ChainData.BlockHash) == 0 {
+
+			return false
+		}
+
+		// Once the ignore tree includes the ignored asset outpoint, we
+		// know that the supply commitment has been updated.
+		if peerFetchResp.IgnoreSubtreeRoot == nil {
+			return false
+		}
+
+		return true
+	}, defaultWaitTimeout, time.Second)
+
+	require.NotNil(t.t, peerFetchResp)
+	require.Len(t.t, peerFetchResp.IssuanceLeaves, 1)
+	require.Len(t.t, peerFetchResp.BurnLeaves, 0)
+	require.Len(t.t, peerFetchResp.IgnoreLeaves, 2)
+
+	require.EqualValues(
+		t.t, rpcAsset.Amount,
+		peerFetchResp.IssuanceLeaves[0].LeafNode.RootSum,
+	)
+	require.EqualValues(
+		t.t, rpcAsset.Amount,
+		peerFetchResp.IgnoreSubtreeRoot.RootNode.RootSum,
+	)
 }
 
 // AssertInclusionProof checks that the inclusion proof for a given leaf key

mssmt/node.go

@@ -4,6 +4,7 @@ import (
 	"crypto/sha256"
 	"encoding/binary"
 	"encoding/hex"
+	"fmt"
 )
 
 const (
@@ -23,6 +24,20 @@ var (
 // NodeHash represents the key of a MS-SMT node.
 type NodeHash [hashSize]byte
 
+// NewNodeHashFromBytes creates a new NodeHash from a byte slice.
+func NewNodeHashFromBytes(b []byte) (NodeHash, error) {
+	var zero NodeHash
+
+	if len(b) != hashSize {
+		return zero, fmt.Errorf("invalid hash size: %d", len(b))
+	}
+
+	var h NodeHash
+	copy(h[:], b)
+
+	return h, nil
+}
+
 // String returns a NodeHash as a hex-encoded string.
 func (k NodeHash) String() string {
 	return hex.EncodeToString(k[:])

mssmt/proof.go

@@ -1,6 +1,7 @@
 package mssmt
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 
@@ -41,6 +42,38 @@ func NewProof(nodes []Node) *Proof {
 	}
 }
 
+// NewProofFromCompressedBytes initializes a new merkle proof from its
+// compressed byte representation.
+func NewProofFromCompressedBytes(compressedProofBytes []byte) (Proof, error) {
+	var zero Proof
+
+	if len(compressedProofBytes) == 0 {
+		return zero, fmt.Errorf("compressed proof bytes are empty")
+	}
+
+	var compressedProof CompressedProof
+	reader := bytes.NewReader(compressedProofBytes)
+	if err := compressedProof.Decode(reader); err != nil {
+		return zero, fmt.Errorf("decode compressed proof: %w", err)
+	}
+
+	// Fail if extra data follows a valid proof encoding.
+	if remaining := reader.Len(); remaining != 0 {
+		return zero, fmt.Errorf("trailing data after compressed "+
+			"proof: %d bytes", remaining)
+	}
+
+	p, err := compressedProof.Decompress()
+	if err != nil {
+		return zero, fmt.Errorf("decompress proof: %w", err)
+	}
+	if p == nil {
+		return zero, fmt.Errorf("decompressor returned nil proof")
+	}
+
+	return *p, nil
+}
+
 // Root returns the root node obtained by walking up the tree.
 func (p Proof) Root(key [32]byte, leaf Node) *BranchNode {
 	// Note that we don't need to check the error here since the only point