multi: remove now unused DeclaredKnown field

Since we can now declare more than just knowledge of a script key by
giving it a specific type, we no longer need the boolean flag that was
added as a temporary workaround.

Author: guggero

address/book.go

@@ -134,13 +134,9 @@ type Storage interface {
 
 	// InsertScriptKey inserts an address related script key into the
 	// database, so it can be recognized as belonging to the wallet when a
-	// transfer comes in later on. The script key can be declared as known
-	// if it contains an internal key that isn't derived by the backing
-	// wallet (e.g. NUMS key) but it should still be recognized as a key
-	// being relevant for the local wallet (e.g. show assets received on
-	// this key in the asset list and balances).
+	// transfer comes in later on.
 	InsertScriptKey(ctx context.Context, scriptKey asset.ScriptKey,
-		declareAsKnown bool, keyType asset.ScriptKeyType) error
+		keyType asset.ScriptKeyType) error
 }
 
 // KeyRing is used to create script and internal keys for Taproot Asset
@@ -406,7 +402,7 @@ func (b *Book) NewAddressWithKeys(ctx context.Context, addrVersion Version,
 	// through an RPC call. So we make a guess here.
 	keyType := scriptKey.GuessType()
 
-	err = b.cfg.Store.InsertScriptKey(ctx, scriptKey, true, keyType)
+	err = b.cfg.Store.InsertScriptKey(ctx, scriptKey, keyType)
 	if err != nil {
 		return nil, fmt.Errorf("unable to insert script key: %w", err)
 	}
@@ -443,11 +439,9 @@ func (b *Book) IsLocalKey(ctx context.Context,
 
 // InsertScriptKey inserts an address related script key into the database.
 func (b *Book) InsertScriptKey(ctx context.Context, scriptKey asset.ScriptKey,
-	declareAsKnown bool, keyType asset.ScriptKeyType) error {
+	keyType asset.ScriptKeyType) error {
 
-	return b.cfg.Store.InsertScriptKey(
-		ctx, scriptKey, declareAsKnown, keyType,
-	)
+	return b.cfg.Store.InsertScriptKey(ctx, scriptKey, keyType)
 }
 
 // NextInternalKey derives then inserts an internal key into the database to
@@ -482,9 +476,7 @@ func (b *Book) NextScriptKey(ctx context.Context,
 	}
 
 	scriptKey := asset.NewScriptKeyBip86(keyDesc)
-	err = b.cfg.Store.InsertScriptKey(
-		ctx, scriptKey, true, asset.ScriptKeyBip86,
-	)
+	err = b.cfg.Store.InsertScriptKey(ctx, scriptKey, asset.ScriptKeyBip86)
 	if err != nil {
 		return asset.ScriptKey{}, err
 	}

asset/asset.go

@@ -1049,15 +1049,6 @@ type TweakedScriptKey struct {
 	// public key. If this is nil, then a BIP-0086 tweak is assumed.
 	Tweak []byte
 
-	// DeclaredKnown indicates that this script key has been explicitly
-	// declared as being important to the local wallet, even if it might not
-	// be fully known to the local wallet. This could perhaps also be named
-	// "imported", though that might imply that the corresponding private
-	// key was also somehow imported and available. The only relevance this
-	// flag has is that assets with a declared key are shown in the asset
-	// list/balance.
-	DeclaredKnown bool
-
 	// Type is the type of script key that is being used.
 	Type ScriptKeyType
 }
@@ -1130,12 +1121,9 @@ func (s *ScriptKey) IsEqual(otherScriptKey *ScriptKey) bool {
 // the local wallet or was explicitly declared to be known by using the
 // DeclareScriptKey RPC. Knowing the key conceptually means the key belongs to
 // the local wallet or is at least known by a software that operates on the
-// local wallet. The DeclaredAsKnown flag is never serialized in proofs, so this
-// is never explicitly set for keys foreign to the local wallet. Therefore, if
-// this method returns true for a script key, it means the asset with the script
-// key will be shown in the wallet balance.
+// local wallet.
 func (s *ScriptKey) DeclaredAsKnown() bool {
-	return s.TweakedScriptKey != nil && s.TweakedScriptKey.DeclaredKnown
+	return s.TweakedScriptKey != nil && s.Type != ScriptKeyUnknown
 }
 
 // HasScriptPath returns true if we know the internals of the script key and
@@ -1606,8 +1594,7 @@ func (a *Asset) Copy() *Asset {
 
 	if a.ScriptKey.TweakedScriptKey != nil {
 		assetCopy.ScriptKey.TweakedScriptKey = &TweakedScriptKey{
-			DeclaredKnown: a.ScriptKey.DeclaredKnown,
-			Type:          a.ScriptKey.Type,
+			Type: a.ScriptKey.Type,
 		}
 		assetCopy.ScriptKey.RawKey = a.ScriptKey.RawKey
 

asset/generators.go

@@ -71,9 +71,8 @@ var (
 	})
 	TweakedScriptKeyGen = rapid.Custom(func(t *rapid.T) TweakedScriptKey {
 		return TweakedScriptKey{
-			RawKey:        KeyDescGen.Draw(t, "raw_key"),
-			Tweak:         HashBytesGen.Draw(t, "tweak"),
-			DeclaredKnown: rapid.Bool().Draw(t, "declared_known"),
+			RawKey: KeyDescGen.Draw(t, "raw_key"),
+			Tweak:  HashBytesGen.Draw(t, "tweak"),
 			Type: ScriptKeyType(
 				rapid.Int16().Draw(t, "script_key_type"),
 			),

rpcserver.go

@@ -8147,9 +8147,7 @@ func (r *rpcServer) DeclareScriptKey(ctx context.Context,
 		return nil, fmt.Errorf("script key type must be set")
 	}
 
-	err = r.cfg.TapAddrBook.InsertScriptKey(
-		ctx, *scriptKey, true, scriptKey.Type,
-	)
+	err = r.cfg.TapAddrBook.InsertScriptKey(ctx, *scriptKey, scriptKey.Type)
 	if err != nil {
 		return nil, fmt.Errorf("error inserting script key: %w", err)
 	}

tapchannel/aux_sweeper.go

@@ -1265,7 +1265,7 @@ func (a *AuxSweeper) importCommitScriptKeys(req lnwallet.ResolutionReq) error {
 	ctxb := context.Background()
 	for _, key := range keysToImport {
 		err := a.cfg.AddrBook.InsertScriptKey(
-			ctxb, key, true, asset.ScriptKeyScriptPathChannel,
+			ctxb, key, asset.ScriptKeyScriptPathChannel,
 		)
 		if err != nil {
 			return fmt.Errorf("unable to insert script "+
@@ -1299,7 +1299,7 @@ func (a *AuxSweeper) importOutputScriptKeys(desc tapscriptSweepDescs) error {
 			limitSpewer.Sdump(scriptKey))
 
 		return a.cfg.AddrBook.InsertScriptKey(
-			ctxb, scriptKey, true, asset.ScriptKeyScriptPathChannel,
+			ctxb, scriptKey, asset.ScriptKeyScriptPathChannel,
 		)
 	}
 
@@ -1494,7 +1494,7 @@ func (a *AuxSweeper) importCommitTx(req lnwallet.ResolutionReq,
 	// balance correctly.
 	ctxb := context.Background()
 	err := a.cfg.AddrBook.InsertScriptKey(
-		ctxb, fundingScriptKey, true, asset.ScriptKeyScriptPathChannel,
+		ctxb, fundingScriptKey, asset.ScriptKeyScriptPathChannel,
 	)
 	if err != nil {
 		return fmt.Errorf("unable to insert script key: %w", err)

tapchannel/commitment.go

@@ -1495,7 +1495,7 @@ func deriveFundingScriptKey(ctx context.Context, addrBook address.Storage,
 	// the asset will be materialized in the asset table and show up in the
 	// balance correctly.
 	err := addrBook.InsertScriptKey(
-		ctx, fundingScriptKey, true, asset.ScriptKeyScriptPathChannel,
+		ctx, fundingScriptKey, asset.ScriptKeyScriptPathChannel,
 	)
 	if err != nil {
 		return asset.ScriptKey{}, fmt.Errorf("unable to insert script "+

tapdb/addrs.go

@@ -652,8 +652,7 @@ func (t *TapAddressBook) InsertInternalKey(ctx context.Context,
 // it can be recognized as belonging to the wallet when a transfer comes in
 // later on.
 func (t *TapAddressBook) InsertScriptKey(ctx context.Context,
-	scriptKey asset.ScriptKey, declaredKnown bool,
-	keyType asset.ScriptKeyType) error {
+	scriptKey asset.ScriptKey, keyType asset.ScriptKeyType) error {
 
 	var writeTxOpts AddrBookTxOptions
 	return t.db.ExecTx(ctx, &writeTxOpts, func(q AddrBook) error {
@@ -669,7 +668,6 @@ func (t *TapAddressBook) InsertScriptKey(ctx context.Context,
 			InternalKeyID:    internalKeyID,
 			TweakedScriptKey: scriptKey.PubKey.SerializeCompressed(),
 			Tweak:            scriptKey.Tweak,
-			DeclaredKnown:    sqlBool(declaredKnown),
 			KeyType:          sqlInt16(keyType),
 		})
 		return err

tapdb/addrs_test.go

@@ -3,7 +3,6 @@ package tapdb
 import (
 	"context"
 	"database/sql"
-	"fmt"
 	"math/rand"
 	"testing"
 	"time"
@@ -660,40 +659,12 @@ func randScriptKey(t *testing.T) asset.ScriptKey {
 	return scriptKey
 }
 
-// insertScriptKeyWithNull is a helper function that inserts a script key with a
-// a NULL value for declared known. We use this so we can insert a NULL vs an
-// actual value. It is identical to the InsertScriptKey.
-func insertScriptKeyWithNull(ctx context.Context,
-	key asset.ScriptKey) func(AddrBook) error {
-
-	return func(q AddrBook) error {
-		internalKeyID, err := insertInternalKey(
-			ctx, q, key.RawKey,
-		)
-		if err != nil {
-			return fmt.Errorf("error inserting internal key: %w",
-				err)
-		}
-
-		_, err = q.UpsertScriptKey(ctx, NewScriptKey{
-			InternalKeyID:    internalKeyID,
-			TweakedScriptKey: key.PubKey.SerializeCompressed(),
-			Tweak:            key.Tweak,
-			DeclaredKnown: sql.NullBool{
-				Valid: false,
-			},
-		})
-		return err
-	}
-}
-
 func assertKeyKnowledge(t *testing.T, ctx context.Context,
-	addrBook *TapAddressBook, scriptKey asset.ScriptKey, known bool,
+	addrBook *TapAddressBook, scriptKey asset.ScriptKey,
 	keyType asset.ScriptKeyType) {
 
 	dbScriptKey, err := addrBook.FetchScriptKey(ctx, scriptKey.PubKey)
 	require.NoError(t, err)
-	require.Equal(t, known, dbScriptKey.DeclaredKnown)
 	require.Equal(t, keyType, dbScriptKey.Type)
 }
 
@@ -705,87 +676,6 @@ func assertTweak(t *testing.T, ctx context.Context, addrBook *TapAddressBook,
 	require.Equal(t, tweak, dbScriptKey.Tweak)
 }
 
-// TestScriptKeyKnownUpsert tests that we can insert a script key, then insert
-// it again declared as known.
-func TestScriptKeyKnownUpsert(t *testing.T) {
-	t.Parallel()
-
-	// First, make a new addr book instance we'll use in the test below.
-	testClock := clock.NewTestClock(time.Now())
-	addrBook, _ := newAddrBook(t, testClock)
-
-	ctx := context.Background()
-
-	// In this test, we insert the known field as false, and make sure we
-	// can flip it back to true.
-	t.Run("false_to_true", func(t *testing.T) {
-		known := false
-		scriptKey := randScriptKey(t)
-
-		// We'll insert a random script key into the database. We won't
-		// declare it as known though.
-		err := addrBook.InsertScriptKey(
-			ctx, scriptKey, known, asset.ScriptKeyBip86,
-		)
-		require.NoError(t, err)
-
-		// We'll fetch the script key and confirm that it's not known.
-		assertKeyKnowledge(
-			t, ctx, addrBook, scriptKey, known,
-			asset.ScriptKeyBip86,
-		)
-
-		known = true
-
-		// We'll now insert it again, but this time declare it as known.
-		err = addrBook.InsertScriptKey(
-			ctx, scriptKey, known, asset.ScriptKeyBip86,
-		)
-		require.NoError(t, err)
-
-		// We'll fetch the script key and confirm that it's known.
-		assertKeyKnowledge(
-			t, ctx, addrBook, scriptKey, known,
-			asset.ScriptKeyBip86,
-		)
-	})
-
-	// In this test, we insert a NULL value, and make sure that it can still
-	// be set to true.
-	t.Run("null_to_true", func(t *testing.T) {
-		known := false
-		scriptKey := randScriptKey(t)
-
-		// We'll lift the internal routine of InsertScriptKey so we can
-		// insert an actual NULL here.
-		err := addrBook.db.ExecTx(
-			ctx, &AddrBookTxOptions{},
-			insertScriptKeyWithNull(ctx, scriptKey),
-		)
-		require.NoError(t, err)
-
-		// We'll fetch the script key and confirm that it's not known.
-		assertKeyKnowledge(
-			t, ctx, addrBook, scriptKey, known,
-			asset.ScriptKeyUnknown,
-		)
-
-		known = true
-
-		// We'll now insert it again, but this time declare it as known.
-		err = addrBook.InsertScriptKey(
-			ctx, scriptKey, known, asset.ScriptKeyBip86,
-		)
-		require.NoError(t, err)
-
-		// We'll fetch the script key and confirm that it's known.
-		assertKeyKnowledge(
-			t, ctx, addrBook, scriptKey, known,
-			asset.ScriptKeyBip86,
-		)
-	})
-}
-
 // TestScriptKeyTweakUpsert tests that we can insert a script key, then insert
 // it again when we know the tweak for it.
 func TestScriptKeyTweakUpsert(t *testing.T) {
@@ -800,40 +690,35 @@ func TestScriptKeyTweakUpsert(t *testing.T) {
 	// In this test, we insert the tweak as NULL, and make sure we overwrite
 	// it with an actual value again later.
 	t.Run("null_to_value", func(t *testing.T) {
-		known := false
 		scriptKey := randScriptKey(t)
 		scriptKey.Tweak = nil
 
 		// We'll insert a random script key into the database. We won't
 		// declare it as known though, and it doesn't have the tweak.
 		err := addrBook.InsertScriptKey(
-			ctx, scriptKey, known,
-			asset.ScriptKeyScriptPathExternal,
+			ctx, scriptKey, asset.ScriptKeyUnknown,
 		)
 		require.NoError(t, err)
 
 		// We'll fetch the script key and confirm that it's not known.
 		assertKeyKnowledge(
-			t, ctx, addrBook, scriptKey, known,
-			asset.ScriptKeyScriptPathExternal,
+			t, ctx, addrBook, scriptKey, asset.ScriptKeyUnknown,
 		)
 		assertTweak(t, ctx, addrBook, scriptKey, nil)
 
-		known = true
 		randTweak := test.RandBytes(32)
 		scriptKey.Tweak = randTweak
 
 		// We'll now insert it again, but this time declare it as known
 		// and also know the tweak.
 		err = addrBook.InsertScriptKey(
-			ctx, scriptKey, known,
-			asset.ScriptKeyScriptPathExternal,
+			ctx, scriptKey, asset.ScriptKeyScriptPathExternal,
 		)
 		require.NoError(t, err)
 
 		// We'll fetch the script key and confirm that it's known.
 		assertKeyKnowledge(
-			t, ctx, addrBook, scriptKey, known,
+			t, ctx, addrBook, scriptKey,
 			asset.ScriptKeyScriptPathExternal,
 		)
 		assertTweak(t, ctx, addrBook, scriptKey, randTweak)
@@ -854,35 +739,32 @@ func TestScriptKeyTypeUpsert(t *testing.T) {
 	// In this test, we insert the type as unknown, and make sure we
 	// overwrite it with an actual value again later.
 	t.Run("null_to_value", func(t *testing.T) {
-		known := true
 		scriptKey := randScriptKey(t)
 		scriptKey.Tweak = nil
 
 		// We'll insert a random script key into the database. It is
 		// declared as known, but doesn't have a known type.
 		err := addrBook.InsertScriptKey(
-			ctx, scriptKey, known, asset.ScriptKeyUnknown,
+			ctx, scriptKey, asset.ScriptKeyUnknown,
 		)
 		require.NoError(t, err)
 
 		// We'll fetch the script key and confirm that it's not known.
 		assertKeyKnowledge(
-			t, ctx, addrBook, scriptKey, known,
-			asset.ScriptKeyUnknown,
+			t, ctx, addrBook, scriptKey, asset.ScriptKeyUnknown,
 		)
 		assertTweak(t, ctx, addrBook, scriptKey, nil)
 
 		// We'll now insert it again, but this time declare it as known
 		// and also know the tweak.
 		err = addrBook.InsertScriptKey(
-			ctx, scriptKey, known, asset.ScriptKeyBip86,
+			ctx, scriptKey, asset.ScriptKeyBip86,
 		)
 		require.NoError(t, err)
 
 		// We'll fetch the script key and confirm that it's known.
 		assertKeyKnowledge(
-			t, ctx, addrBook, scriptKey, known,
-			asset.ScriptKeyBip86,
+			t, ctx, addrBook, scriptKey, asset.ScriptKeyBip86,
 		)
 	})
 }