wallet+wtxmgr: check credit in FetchOutpointInfo

To decide whether an outpoint belongs to the wallet or not, we need to
further check that the specified output index is indeed a credit paid to
us.

Author: yyforyongyu

wallet/createtx_test.go

@@ -213,6 +213,47 @@ func addUtxo(t *testing.T, w *Wallet, incomingTx *wire.MsgTx) {
 	}
 }
 
+// addTxAndCredit adds the given transaction to the wallet's database marked as
+// a confirmed UTXO specified by the creditIndex.
+func addTxAndCredit(t *testing.T, w *Wallet, tx *wire.MsgTx,
+	creditIndex uint32) {
+
+	var b bytes.Buffer
+	require.NoError(t, tx.Serialize(&b), "unable to serialize tx")
+
+	txBytes := b.Bytes()
+
+	rec, err := wtxmgr.NewTxRecord(txBytes, time.Now())
+	require.NoError(t, err)
+
+	// The block meta will be inserted to tell the wallet this is a
+	// confirmed transaction.
+	block := &wtxmgr.BlockMeta{
+		Block: wtxmgr.Block{
+			Hash:   *testBlockHash,
+			Height: testBlockHeight,
+		},
+		Time: time.Unix(1387737310, 0),
+	}
+
+	err = walletdb.Update(w.db, func(dbTx walletdb.ReadWriteTx) error {
+		ns := dbTx.ReadWriteBucket(wtxmgrNamespaceKey)
+		err = w.TxStore.InsertTx(ns, rec, block)
+		if err != nil {
+			return err
+		}
+
+		// Add the specified output as credit.
+		err = w.TxStore.AddCredit(ns, rec, block, creditIndex, false)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+	require.NoError(t, err, "failed inserting tx")
+}
+
 // TestInputYield verifies the functioning of the inputYieldsPositively.
 func TestInputYield(t *testing.T) {
 	t.Parallel()

wallet/utxos.go

@@ -174,6 +174,12 @@ func (w *Wallet) FetchOutpointInfo(prevOut *wire.OutPoint) (*wire.MsgTx,
 			numOutputs)
 	}
 
+	// Exit early if the output doesn't belong to our wallet. We know it's
+	// our UTXO iff the `TxDetails` has a credit record on this output.
+	if !txDetail.HasOutput(prevOut.Index) {
+		return nil, nil, 0, ErrNotMine
+	}
+
 	pkScript := txDetail.TxRecord.MsgTx.TxOut[prevOut.Index].PkScript
 
 	// Determine the number of confirmations the output currently has.

wallet/utxos_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/btcsuite/btcd/btcutil/hdkeychain"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcwallet/waddrmgr"
@@ -129,6 +130,82 @@ func TestFetchOutpointInfo(t *testing.T) {
 	require.Equal(t, int64(0-testBlockHeight), confirmations)
 }
 
+// TestFetchOutpointInfoErr checks when the wallet cannot find an output, a
+// proper error is returned.
+func TestFetchOutpointInfoErr(t *testing.T) {
+	t.Parallel()
+
+	w, cleanup := testWallet(t)
+	defer cleanup()
+
+	// Create an address we can use to send some coins to.
+	addr, err := w.CurrentAddress(0, waddrmgr.KeyScopeBIP0084)
+	require.NoError(t, err)
+	p2shAddr, err := txscript.PayToAddrScript(addr)
+	require.NoError(t, err)
+
+	// Create a tx that has two outputs - output1 belongs to the wallet,
+	// output2 is external.
+	output1 := wire.NewTxOut(100000, p2shAddr)
+	output2 := wire.NewTxOut(100000, p2shAddr)
+	tx := &wire.MsgTx{
+		TxIn: []*wire.TxIn{{}},
+		TxOut: []*wire.TxOut{
+			output1,
+			output2,
+		},
+	}
+
+	// Add the tx and its first output as the credit.
+	addTxAndCredit(t, w, tx, 0)
+
+	testCases := []struct {
+		name    string
+		prevOut *wire.OutPoint
+
+		// TODO(yy): refator `FetchOutpointInfo` to return wrapped
+		// errors.
+		errExpected string
+	}{
+		{
+			name: "no tx details",
+			prevOut: &wire.OutPoint{
+				Hash:  chainhash.Hash{1, 2, 3},
+				Index: 1000,
+			},
+			errExpected: "does not belong to the wallet",
+		},
+		{
+			name: "invalid output index",
+			prevOut: &wire.OutPoint{
+				Hash:  tx.TxHash(),
+				Index: 1000,
+			},
+			errExpected: "invalid output index",
+		},
+		{
+			name: "no credit found",
+			prevOut: &wire.OutPoint{
+				Hash:  tx.TxHash(),
+				Index: 1000,
+			},
+			errExpected: "invalid output index",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Look up the UTXO for the outpoint now and compare it
+			// to the expected error.
+			tx, out, conf, err := w.FetchOutpointInfo(tc.prevOut)
+			require.ErrorContains(t, err, tc.errExpected)
+			require.Nil(t, tx)
+			require.Nil(t, out)
+			require.Zero(t, conf)
+		})
+	}
+}
+
 // TestFetchDerivationInfo checks that the wallet can gather the derivation
 // info about an output based on the pkScript.
 func TestFetchDerivationInfo(t *testing.T) {

wtxmgr/query.go

@@ -42,6 +42,19 @@ type TxDetails struct {
 	Label   string
 }
 
+// HasOutpoint takes an output identified by its output index and determines
+// whether the TxDetails contains this output. If the TxDetails doesn't have
+// this output, it means this output doesn't belong to our wallet.
+func (t *TxDetails) HasOutput(outputIndex uint32) bool {
+	for _, cred := range t.Credits {
+		if outputIndex == cred.Index {
+			return true
+		}
+	}
+
+	return false
+}
+
 // minedTxDetails fetches the TxDetails for the mined transaction with hash
 // txHash and the passed tx record key and value.
 func (s *Store) minedTxDetails(ns walletdb.ReadBucket, txHash *chainhash.Hash, recKey, recVal []byte) (*TxDetails, error) {