supplyverifier: add pull syncer and non-universe node verification

cmd/commands/universe.go

@@ -1638,21 +1638,6 @@ var fetchSupplyCommitCmd = cli.Command{
 			Usage:    "the group key of the asset group to fetch",
 			Required: true,
 		},
-		&cli.StringSliceFlag{
-			Name: "issuance_leaf_keys",
-			Usage: "a list of issuance leaf keys to fetch " +
-				"inclusion proofs for",
-		},
-		&cli.StringSliceFlag{
-			Name: "burn_leaf_keys",
-			Usage: "a list of burn leaf keys to fetch inclusion " +
-				"proofs for",
-		},
-		&cli.StringSliceFlag{
-			Name: "ignore_leaf_keys",
-			Usage: "a list of ignore leaf keys to fetch " +
-				"inclusion proofs for",
-		},
 	},
 	Action: fetchSupplyCommit,
 }
@@ -1668,26 +1653,6 @@ func fetchSupplyCommit(ctx *cli.Context) error {
 		},
 	}
 
-	issuanceKeys, err := parseHexStrings(
-		ctx.StringSlice("issuance_leaf_keys"),
-	)
-	if err != nil {
-		return fmt.Errorf("invalid issuance_leaf_keys: %w", err)
-	}
-	req.IssuanceLeafKeys = issuanceKeys
-
-	burnKeys, err := parseHexStrings(ctx.StringSlice("burn_leaf_keys"))
-	if err != nil {
-		return fmt.Errorf("invalid burn_leaf_keys: %w", err)
-	}
-	req.BurnLeafKeys = burnKeys
-
-	ignoreKeys, err := parseHexStrings(ctx.StringSlice("ignore_leaf_keys"))
-	if err != nil {
-		return fmt.Errorf("invalid ignore_leaf_keys: %w", err)
-	}
-	req.IgnoreLeafKeys = ignoreKeys
-
 	resp, err := client.FetchSupplyCommit(cliCtx, req)
 	if err != nil {
 		return err
@@ -1719,6 +1684,21 @@ var fetchSupplyLeavesCmd = cli.Command{
 			Usage:    "the end of the block height range",
 			Required: true,
 		},
+		&cli.StringSliceFlag{
+			Name: "issuance_leaf_keys",
+			Usage: "a list of issuance leaf keys to fetch " +
+				"inclusion proofs for",
+		},
+		&cli.StringSliceFlag{
+			Name: "burn_leaf_keys",
+			Usage: "a list of burn leaf keys to fetch inclusion " +
+				"proofs for",
+		},
+		&cli.StringSliceFlag{
+			Name: "ignore_leaf_keys",
+			Usage: "a list of ignore leaf keys to fetch " +
+				"inclusion proofs for",
+		},
 	},
 	Action: fetchSupplyLeaves,
 }
@@ -1736,6 +1716,26 @@ func fetchSupplyLeaves(ctx *cli.Context) error {
 		BlockHeightEnd:   uint32(ctx.Uint64("block_height_end")),
 	}
 
+	issuanceKeys, err := parseHexStrings(
+		ctx.StringSlice("issuance_leaf_keys"),
+	)
+	if err != nil {
+		return fmt.Errorf("invalid issuance_leaf_keys: %w", err)
+	}
+	req.IssuanceLeafKeys = issuanceKeys
+
+	burnKeys, err := parseHexStrings(ctx.StringSlice("burn_leaf_keys"))
+	if err != nil {
+		return fmt.Errorf("invalid burn_leaf_keys: %w", err)
+	}
+	req.BurnLeafKeys = burnKeys
+
+	ignoreKeys, err := parseHexStrings(ctx.StringSlice("ignore_leaf_keys"))
+	if err != nil {
+		return fmt.Errorf("invalid ignore_leaf_keys: %w", err)
+	}
+	req.IgnoreLeafKeys = ignoreKeys
+
 	resp, err := client.FetchSupplyLeaves(cliCtx, req)
 	if err != nil {
 		return err

config.go

@@ -19,6 +19,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/tapgarden"
 	"github.com/lightninglabs/taproot-assets/universe"
 	"github.com/lightninglabs/taproot-assets/universe/supplycommit"
+	"github.com/lightninglabs/taproot-assets/universe/supplyverifier"
 	"github.com/lightningnetwork/lnd"
 	"github.com/lightningnetwork/lnd/build"
 	"github.com/lightningnetwork/lnd/signal"
@@ -199,6 +200,11 @@ type Config struct {
 
 	IgnoreChecker *tapdb.CachingIgnoreChecker
 
+	// SupplyVerifyManager is a service that is used to verify supply
+	// commitments for assets. Supply commitments are issuer published
+	// attestations of the total supply of an asset.
+	SupplyVerifyManager *supplyverifier.Manager
+
 	UniverseArchive *universe.Archive
 
 	UniverseSyncer universe.Syncer

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

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

fn/func.go

@@ -93,6 +93,29 @@ func MapErr[I, O any, S []I](s S, f func(I) (O, error)) ([]O, error) {
 	return output, nil
 }
 
+// MapErrWithPtr applies the given fallible mapping function to each element of
+// the given slice and generates a new slice. This is identical to MapErr, but
+// can be used when the callback returns a pointer, and returns early if any
+// single mapping fails.
+func MapErrWithPtr[I, O any, S []I](s S, f func(I) (*O, error)) ([]O, error) {
+	output := make([]O, len(s))
+	for i, x := range s {
+		outPtr, err := f(x)
+		if err != nil {
+			return nil, err
+		}
+
+		if outPtr == nil {
+			return nil, fmt.Errorf("nil pointer returned for "+
+				"item %d", i)
+		}
+
+		output[i] = *outPtr
+	}
+
+	return output, nil
+}
+
 // FlatMapErr applies the given mapping function to each element of the given
 // slice, concatenates the results into a new slice, and returns an error if
 // the mapping function fails.

itest/assertions.go

@@ -2786,8 +2786,9 @@ func UpdateAndMineSupplyCommit(t *testing.T, ctx context.Context,
 // it when the specified condition is met.
 func WaitForSupplyCommit(t *testing.T, ctx context.Context,
 	tapd unirpc.UniverseClient, groupKeyBytes []byte,
+	spentCommitOutpoint fn.Option[wire.OutPoint],
 	condition func(*unirpc.FetchSupplyCommitResponse) bool,
-) *unirpc.FetchSupplyCommitResponse {
+) (*unirpc.FetchSupplyCommitResponse, wire.OutPoint) {
 
 	groupKeyReq := &unirpc.FetchSupplyCommitRequest_GroupKeyBytes{
 		GroupKeyBytes: groupKeyBytes,
@@ -2796,18 +2797,50 @@ func WaitForSupplyCommit(t *testing.T, ctx context.Context,
 	var fetchResp *unirpc.FetchSupplyCommitResponse
 	var err error
 
-	require.Eventually(t, func() bool {
-		fetchResp, err = tapd.FetchSupplyCommit(
-			ctx, &unirpc.FetchSupplyCommitRequest{
-				GroupKey: groupKeyReq,
+	// By default, we start the fetch from the very first commitment.
+	// If a spent outpoint is given, we start from there.
+	req := &unirpc.FetchSupplyCommitRequest{
+		GroupKey: groupKeyReq,
+		Locator: &unirpc.FetchSupplyCommitRequest_VeryFirst{
+			VeryFirst: true,
+		},
+	}
+
+	// nolint: lll
+	spentCommitOutpoint.WhenSome(func(outPoint wire.OutPoint) {
+		req = &unirpc.FetchSupplyCommitRequest{
+			GroupKey: groupKeyReq,
+			Locator: &unirpc.FetchSupplyCommitRequest_SpentCommitOutpoint{
+				SpentCommitOutpoint: &taprpc.OutPoint{
+					Txid:        outPoint.Hash[:],
+					OutputIndex: outPoint.Index,
+				},
 			},
-		)
+		}
+	})
+
+	require.Eventually(t, func() bool {
+		fetchResp, err = tapd.FetchSupplyCommit(ctx, req)
 		if err != nil {
 			return false
 		}
 
 		return fetchResp != nil && condition(fetchResp)
 	}, defaultWaitTimeout, time.Second)
 
-	return fetchResp
+	// Return the supply commit outpoint used to fetch the next supply
+	// commitment. The next commitment is retrieved by referencing the
+	// outpoint of the previously spent commitment.
+	require.NotNil(t, fetchResp)
+
+	var msgTx wire.MsgTx
+	err = msgTx.Deserialize(bytes.NewReader(fetchResp.ChainData.Txn))
+	require.NoError(t, err)
+
+	supplyCommitOutpoint := wire.OutPoint{
+		Hash:  msgTx.TxHash(),
+		Index: fetchResp.ChainData.TxOutIdx,
+	}
+
+	return fetchResp, supplyCommitOutpoint
 }

itest/supply_commit_mint_burn_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
 	taprootassets "github.com/lightninglabs/taproot-assets"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/taprpc"
@@ -48,18 +49,19 @@ func testSupplyCommitMintBurn(t *harnessTest) {
 	// Update the on-chain supply commitment for the asset group.
 	//
 	// TODO(roasbeef): still rely on the time based ticker here?
-	t.Log("Updating and mining supply commitment for asset group")
+	t.Log("Create first supply commitment tx for asset group")
 	UpdateAndMineSupplyCommit(
 		t.t, ctxb, t.tapd, t.lndHarness.Miner().Client,
 		groupKeyBytes, 1,
 	)
 
 	// Fetch the latest supply commitment for the asset group.
-	t.Log("Fetching supply commitment to verify mint leaves")
-	fetchResp := WaitForSupplyCommit(
-		t.t, ctxb, t.tapd, groupKeyBytes,
+	t.Log("Fetching first supply commitment to verify mint leaves")
+	fetchResp, supplyOutpoint := WaitForSupplyCommit(
+		t.t, ctxb, t.tapd, groupKeyBytes, fn.None[wire.OutPoint](),
 		func(resp *unirpc.FetchSupplyCommitResponse) bool {
-			return resp.BlockHeight > 0 && len(resp.BlockHash) > 0
+			return resp.ChainData.BlockHeight > 0 &&
+				len(resp.ChainData.BlockHash) > 0
 		},
 	)
 
@@ -72,7 +74,7 @@ func testSupplyCommitMintBurn(t *harnessTest) {
 
 	// Verify the issuance leaf inclusion in the supply tree.
 	AssertSubtreeInclusionProof(
-		t, fetchResp.SupplyCommitmentRoot.RootHash,
+		t, fetchResp.ChainData.SupplyRootHash,
 		fetchResp.IssuanceSubtreeRoot,
 	)
 
@@ -106,8 +108,6 @@ func testSupplyCommitMintBurn(t *harnessTest) {
 	)
 
 	t.Log("Updating supply commitment after second mint")
-
-	// Update and mine the supply commitment after second mint.
 	UpdateAndMineSupplyCommit(
 		t.t, ctxb, t.tapd, t.lndHarness.Miner().Client,
 		groupKeyBytes, 1,
@@ -119,8 +119,8 @@ func testSupplyCommitMintBurn(t *harnessTest) {
 	expectedTotal := int64(
 		mintReq.Asset.Amount + secondMintReq.Asset.Amount,
 	)
-	fetchResp = WaitForSupplyCommit(
-		t.t, ctxb, t.tapd, groupKeyBytes,
+	fetchResp, supplyOutpoint = WaitForSupplyCommit(
+		t.t, ctxb, t.tapd, groupKeyBytes, fn.Some(supplyOutpoint),
 		func(resp *unirpc.FetchSupplyCommitResponse) bool {
 			return resp.IssuanceSubtreeRoot != nil &&
 				resp.IssuanceSubtreeRoot.RootNode.RootSum == expectedTotal //nolint:lll
@@ -175,7 +175,8 @@ func testSupplyCommitMintBurn(t *harnessTest) {
 	t.Log("Verifying supply tree includes burn leaves")
 
 	// Fetch and verify the supply tree now includes burn leaves.
-	fetchResp = WaitForSupplyCommit(t.t, ctxb, t.tapd, groupKeyBytes,
+	fetchResp, _ = WaitForSupplyCommit(
+		t.t, ctxb, t.tapd, groupKeyBytes, fn.Some(supplyOutpoint),
 		func(resp *unirpc.FetchSupplyCommitResponse) bool {
 			return resp.BurnSubtreeRoot != nil &&
 				resp.BurnSubtreeRoot.RootNode.RootSum == int64(burnAmt) //nolint:lll
@@ -184,7 +185,7 @@ func testSupplyCommitMintBurn(t *harnessTest) {
 
 	// Verify the burn subtree inclusion in the supply tree.
 	AssertSubtreeInclusionProof(
-		t, fetchResp.SupplyCommitmentRoot.RootHash,
+		t, fetchResp.ChainData.SupplyRootHash,
 		fetchResp.BurnSubtreeRoot,
 	)
 
@@ -234,16 +235,16 @@ func testSupplyCommitMintBurn(t *harnessTest) {
 	block := finalMinedBlocks[0]
 	blockHash, _ := t.lndHarness.Miner().GetBestBlock()
 
-	fetchBlockHash, err := chainhash.NewHash(fetchResp.BlockHash)
+	fetchBlockHash, err := chainhash.NewHash(fetchResp.ChainData.BlockHash)
 	require.NoError(t.t, err)
 	require.True(t.t, fetchBlockHash.IsEqual(blockHash))
 
 	// Re-compute the supply commitment root hash from the latest fetch,
 	// then use that to derive the expected commitment output.
 	supplyCommitRootHash := fn.ToArray[[32]byte](
-		fetchResp.SupplyCommitmentRoot.RootHash,
+		fetchResp.ChainData.SupplyRootHash,
 	)
-	internalKey, err := btcec.ParsePubKey(fetchResp.AnchorTxOutInternalKey)
+	internalKey, err := btcec.ParsePubKey(fetchResp.ChainData.InternalKey)
 	require.NoError(t.t, err)
 	expectedTxOut, _, err := supplycommit.RootCommitTxOut(
 		internalKey, nil, supplyCommitRootHash,