Merge pull request #1541 from lightninglabs/1534-refactor-pre-ignore-tree-rpc

Refactor in Preparation for Ignore Tree RPC Endpoints

Author: ffranr

asset/asset.go

@@ -548,19 +548,15 @@ func (t Type) String() string {
 
 // PrevID serves as a reference to an asset's previous input.
 type PrevID struct {
-	// OutPoint refers to the asset's previous output position within a
-	// transaction.
+	// OutPoint is the Bitcoin-level identifier (TXID + vout) of the UTXO
+	// anchoring the asset state.
 	OutPoint wire.OutPoint
 
-	// ID is the asset ID of the previous asset tree.
+	// ID is the TAP-level asset identifier.
 	ID ID
 
-	// TODO(roasbeef): need another ref type for assets w/ a key group?
-
-	// ScriptKey is the previously tweaked Taproot output key committing to
-	// the possible spending conditions of the asset. PrevID is being used
-	// as map keys, so we want to only use data types with fixed and
-	// comparable content, which a btcec.PublicKey might not be.
+	// ScriptKey is the TAP-level Taproot output key that committed to the
+	// asset's spending conditions. Serialized to ensure comparability.
 	ScriptKey SerializedKey
 }
 

itest/assets_test.go

@@ -742,7 +742,7 @@ func testAssetBalances(t *harnessTest) {
 				},
 			},
 			expectError:    true,
-			expectedErrMsg: "invalid Txid",
+			expectedErrMsg: "invalid outpoint txid",
 		},
 		{
 			name: "Fail if AssetId is too short",

proof/archive.go

@@ -136,7 +136,7 @@ type AnnotatedProof struct {
 // Exporter is used to fetch proofs by their unique identifier.
 type Exporter interface {
 	// FetchProof fetches a proof for an asset uniquely identified by the
-	// passed ProofIdentifier.
+	// given locator.
 	//
 	// If a proof cannot be found, then ErrProofNotFound should be
 	// returned. If multiple proofs exist for the given fields of the

proof/mock.go

@@ -356,7 +356,7 @@ func (m *MockProofArchive) FetchIssuanceProof(_ context.Context,
 	}
 
 	// Mimic the pattern matching done with proof file paths in
-	// FileArchiver.FetchIssuanceProof().
+	// FileArchiver.FetchProof().
 	matchingHashes := make([][32]byte, 0)
 	locMatcher := func(locBytes [132]byte, locHash [32]byte) error {
 		if bytes.Equal(locBytes[:32], id[:]) &&

rpcserver.go

@@ -1102,17 +1102,13 @@ func (r *rpcServer) ListAssets(ctx context.Context,
 	}
 
 	if req.AnchorOutpoint != nil {
-		txid, err := chainhash.NewHash(req.AnchorOutpoint.Txid)
+		op, err := rpcutils.UnmarshalOutPoint(req.AnchorOutpoint)
 		if err != nil {
-			return nil, fmt.Errorf("error parsing outpoint: %w",
+			return nil, fmt.Errorf("unmarshalling outpoint: %w",
 				err)
 		}
-		outPoint := &wire.OutPoint{
-			Hash:  *txid,
-			Index: req.AnchorOutpoint.OutputIndex,
-		}
 
-		filters.AnchorPoint = outPoint
+		filters.AnchorPoint = &op
 	}
 
 	scriptKeyType, includeSpent, err := rpcutils.ParseScriptKeyTypeQuery(
@@ -2059,15 +2055,13 @@ func (r *rpcServer) ExportProof(ctx context.Context,
 	// error will be returned and the outpoint needs to be specified to
 	// disambiguate.
 	if req.Outpoint != nil {
-		txid, err := chainhash.NewHash(req.Outpoint.Txid)
+		op, err := rpcutils.UnmarshalOutPoint(req.Outpoint)
 		if err != nil {
-			return nil, fmt.Errorf("error parsing outpoint: %w",
+			return nil, fmt.Errorf("unmarshalling outpoint: %w",
 				err)
 		}
-		outPoint = &wire.OutPoint{
-			Hash:  *txid,
-			Index: req.Outpoint.OutputIndex,
-		}
+
+		outPoint = &op
 	}
 
 	proofBlob, err := r.cfg.ProofArchive.FetchProof(ctx, proof.Locator{
@@ -2260,14 +2254,19 @@ func (r *rpcServer) FundVirtualPsbt(ctx context.Context,
 		)
 		for i, input := range raw.Inputs {
 			if input.Outpoint == nil {
+				// Return an error message which specifically
+				// refers to the index which has a corresponding
+				// nil outpoint.
 				return nil, fmt.Errorf("input at index %d has "+
 					"a nil Outpoint", i)
 			}
 
-			hash, err := chainhash.NewHash(input.Outpoint.Txid)
+			outPoint, err := rpcutils.UnmarshalOutPoint(
+				input.Outpoint,
+			)
 			if err != nil {
-				return nil, fmt.Errorf("input at index %d has "+
-					"invalid Txid: %w", i, err)
+				return nil, fmt.Errorf("unmarshalling "+
+					"outpoint: %w", err)
 			}
 
 			scriptKey, err := parseUserKey(input.ScriptKey)
@@ -2283,12 +2282,8 @@ func (r *rpcServer) FundVirtualPsbt(ctx context.Context,
 			}
 
 			// Decode the input into an asset.PrevID.
-			outpoint := wire.OutPoint{
-				Hash:  *hash,
-				Index: input.Outpoint.OutputIndex,
-			}
 			prevID := asset.PrevID{
-				OutPoint: outpoint,
+				OutPoint: outPoint,
 				ID:       asset.ID(input.Id),
 				ScriptKey: asset.ToSerialized(
 					scriptKey,
@@ -2975,15 +2970,13 @@ func (r *rpcServer) PublishAndLogTransfer(ctx context.Context,
 		FinalTx:   finalTx,
 	}
 	for idx, lndOutpoint := range req.LndLockedUtxos {
-		hash, err := chainhash.NewHash(lndOutpoint.Txid)
+		op, err := rpcutils.UnmarshalOutPoint(lndOutpoint)
 		if err != nil {
-			return nil, fmt.Errorf("error parsing txid: %w", err)
+			return nil, fmt.Errorf("unmarshalling outpoint: %w",
+				err)
 		}
 
-		anchorTx.FundedPsbt.LockedUTXOs[idx] = wire.OutPoint{
-			Hash:  *hash,
-			Index: lndOutpoint.OutputIndex,
-		}
+		anchorTx.FundedPsbt.LockedUTXOs[idx] = op
 	}
 
 	// We now have everything to ship the pre-anchored parcel using the
@@ -5417,7 +5410,7 @@ func (r *rpcServer) AssetLeaves(ctx context.Context,
 		return nil, err
 	}
 
-	assetLeaves, err := r.cfg.UniverseArchive.MintingLeaves(ctx, universeID)
+	assetLeaves, err := r.cfg.UniverseArchive.FetchLeaves(ctx, universeID)
 	if err != nil {
 		return nil, err
 	}
@@ -6310,15 +6303,13 @@ func (r *rpcServer) ProveAssetOwnership(ctx context.Context,
 	// error will be returned and the outpoint needs to be specified to
 	// disambiguate.
 	if req.Outpoint != nil {
-		txid, err := chainhash.NewHash(req.Outpoint.Txid)
+		op, err := rpcutils.UnmarshalOutPoint(req.Outpoint)
 		if err != nil {
-			return nil, fmt.Errorf("error parsing outpoint: %w",
+			return nil, fmt.Errorf("unmarshalling outpoint: %w",
 				err)
 		}
-		outPoint = &wire.OutPoint{
-			Hash:  *txid,
-			Index: req.Outpoint.OutputIndex,
-		}
+
+		outPoint = &op
 	}
 
 	proofBlob, err := r.cfg.ProofArchive.FetchProof(ctx, proof.Locator{
@@ -6605,18 +6596,9 @@ func (r *rpcServer) RemoveUTXOLease(ctx context.Context,
 	req *wrpc.RemoveUTXOLeaseRequest) (*wrpc.RemoveUTXOLeaseResponse,
 	error) {
 
-	if req.Outpoint == nil {
-		return nil, fmt.Errorf("outpoint must be specified")
-	}
-
-	hash, err := chainhash.NewHash(req.Outpoint.Txid)
+	outPoint, err := rpcutils.UnmarshalOutPoint(req.Outpoint)
 	if err != nil {
-		return nil, fmt.Errorf("error parsing txid: %w", err)
-	}
-
-	outPoint := wire.OutPoint{
-		Hash:  *hash,
-		Index: req.Outpoint.OutputIndex,
+		return nil, fmt.Errorf("unmarshaling outpoint: %w", err)
 	}
 
 	err = r.cfg.CoinSelect.ReleaseCoins(ctx, outPoint)
@@ -8898,15 +8880,13 @@ func (r *rpcServer) RegisterTransfer(ctx context.Context,
 	}
 	locator.ScriptKey = *scriptPubKey
 
-	hash, err := chainhash.NewHash(req.Outpoint.Txid)
+	op, err := rpcutils.UnmarshalOutPoint(req.Outpoint)
 	if err != nil {
-		return nil, err
-	}
-	locator.OutPoint = &wire.OutPoint{
-		Hash:  *hash,
-		Index: req.Outpoint.OutputIndex,
+		return nil, fmt.Errorf("unmarshalling outpoint: %w", err)
 	}
 
+	locator.OutPoint = &op
+
 	// Before we query for the proof, we want to make sure the script key is
 	// already known to us. In an interactive transfer, we'd expect a script
 	// key to be derived on the recipient node, so it should already be

rpcutils/marshal.go

@@ -10,6 +10,7 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/asset"
@@ -257,6 +258,25 @@ func UnmarshalGenesisInfo(rpcGen *taprpc.GenesisInfo) (*asset.Genesis, error) {
 	}, nil
 }
 
+// UnmarshalOutPoint parses an outpoint from the RPC variant.
+func UnmarshalOutPoint(rpcOutpoint *taprpc.OutPoint) (wire.OutPoint, error) {
+	var zero wire.OutPoint
+
+	if rpcOutpoint == nil {
+		return zero, fmt.Errorf("unexpected nil RPC outpoint")
+	}
+
+	txid, err := chainhash.NewHash(rpcOutpoint.Txid)
+	if err != nil {
+		return zero, fmt.Errorf("invalid outpoint txid: %w", err)
+	}
+
+	return wire.OutPoint{
+		Hash:  *txid,
+		Index: rpcOutpoint.OutputIndex,
+	}, nil
+}
+
 // UnmarshalTapscriptFullTree parses a Tapscript tree from the RPC variant.
 func UnmarshalTapscriptFullTree(tree *taprpc.TapscriptFullTree) (
 	*asset.TapscriptTreeNodes, error) {

tapcfg/server.go

@@ -154,8 +154,9 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 	groupVerifier := tapgarden.GenGroupVerifier(
 		context.Background(), assetMintingStore,
 	)
-	uniCfg := universe.ArchiveConfig{
-		NewBaseTree: func(id universe.Identifier) universe.BaseBackend {
+	uniArchiveCfg := universe.ArchiveConfig{
+		// nolint: lll
+		NewBaseTree: func(id universe.Identifier) universe.StorageBackend {
 			return tapdb.NewBaseUniverseTree(
 				uniDB, id,
 			)
@@ -284,12 +285,12 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 		ErrChan:   mainErrChan,
 	})
 
-	baseUni := universe.NewArchive(uniCfg)
+	uniArchive := universe.NewArchive(uniArchiveCfg)
 
 	universeSyncer := universe.NewSimpleSyncer(universe.SimpleSyncCfg{
-		LocalDiffEngine:     baseUni,
+		LocalDiffEngine:     uniArchive,
 		NewRemoteDiffEngine: tap.NewRpcUniverseDiff,
-		LocalRegistrar:      baseUni,
+		LocalRegistrar:      uniArchive,
 		SyncBatchSize:       defaultUniverseSyncBatchSize,
 	})
 
@@ -304,7 +305,7 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 		universe.FederationConfig{
 			FederationDB:            federationDB,
 			UniverseSyncer:          universeSyncer,
-			LocalRegistrar:          baseUni,
+			LocalRegistrar:          uniArchive,
 			SyncInterval:            cfg.Universe.SyncInterval,
 			NewRemoteRegistrar:      tap.NewRpcUniverseRegistrar,
 			StaticFederationMembers: federationMembers,
@@ -574,7 +575,7 @@ func genServerConfig(cfg *Config, cfgLogger btclog.Logger,
 		AssetWallet:              assetWallet,
 		CoinSelect:               coinSelect,
 		ChainPorter:              chainPorter,
-		UniverseArchive:          baseUni,
+		UniverseArchive:          uniArchive,
 		UniverseSyncer:           universeSyncer,
 		UniverseFederation:       universeFederation,
 		UniFedSyncAllAssets:      cfg.Universe.SyncAllAssets,

tapdb/ignore_tree.go

@@ -24,7 +24,7 @@ func NewIgnoreUniverseTree(db BatchedUniverseTree) *IgnoreUniverseTree {
 	return &IgnoreUniverseTree{db: db}
 }
 
-// AddTuple adds a new ignore tuples to the ignore tree.
+// AddTuples adds a new ignore tuples to the ignore tree.
 func (it *IgnoreUniverseTree) AddTuples(ctx context.Context,
 	spec asset.Specifier, tuples ...universe.SignedIgnoreTuple,
 ) lfn.Result[universe.AuthIgnoreTuples] {