loopdb: refactor the SwapContract to hold all HTLC keys

This commit adds a new struct to hold all HTLC keys and refactors the
SwapContract which is used by both loopin and loopout swaps to use this
new struct. The newly added internal keys will for now hold the script
keys to keep everything equivalent but are already stored and read back
if the protocol version is set to MuSig2.

Author: bhandras

client_test.go

@@ -240,8 +240,12 @@ func testLoopOutResume(t *testing.T, confs uint32, expired, preimageRevealed,
 				Preimage:        preimage,
 				AmountRequested: amt,
 				CltvExpiry:      744,
-				ReceiverKey:     receiverKey,
-				SenderKey:       senderKey,
+				HtlcKeys: loopdb.HtlcKeys{
+					SenderScriptKey:        senderKey,
+					SenderInternalPubKey:   senderKey,
+					ReceiverScriptKey:      receiverKey,
+					ReceiverInternalPubKey: receiverKey,
+				},
 				MaxSwapFee:      60000,
 				MaxMinerFee:     50000,
 				ProtocolVersion: protocolVersion,

loopdb/loop.go

@@ -10,6 +10,31 @@ import (
 	"github.com/lightningnetwork/lnd/lntypes"
 )
 
+// HtlcKeys is a holder of all keys used when constructing the swap HTLC. Since
+// it's used for both loop in and loop out swaps it may hold partial information
+// about the sender or receiver depending on the swap type.
+type HtlcKeys struct {
+	// SenderScriptKey is the sender's public key that is used in the HTLC,
+	// specifically when constructing the script spend scripts.
+	SenderScriptKey [33]byte
+
+	// SenderInternalPubKey is the sender's internal pubkey that is used in
+	// taproot HTLCs as part of the aggregate internal key.
+	SenderInternalPubKey [33]byte
+
+	// ReceiverScriptKey is the receiver's public key that is used in the
+	// HTLC, specifically when constructing the script spend scripts.
+	ReceiverScriptKey [33]byte
+
+	// ReceiverInternalPubKey is the sender's internal pubkey that is used
+	// in taproot HTLCs as part of the aggregate internal key.
+	ReceiverInternalPubKey [33]byte
+
+	// ClientScriptKeyLocator is the client's key locator for the key used
+	// in the HTLC script spend scripts.
+	ClientScriptKeyLocator keychain.KeyLocator
+}
+
 // SwapContract contains the base data that is serialized to persistent storage
 // for pending swaps.
 type SwapContract struct {
@@ -19,18 +44,8 @@ type SwapContract struct {
 	// AmountRequested is the total amount of the swap.
 	AmountRequested btcutil.Amount
 
-	// SenderKey is the key of the sender that will be used in the on-chain
-	// HTLC.
-	SenderKey [33]byte
-
-	// ReceiverKey is the of the receiver that will be used in the on-chain
-	// HTLC.
-	ReceiverKey [33]byte
-
-	// ClientKeyLocator is the key locator (family and index) for the client
-	// key. It is for the receiver key if this is a loop out contract, or
-	// the sender key if this is a loop in contract.
-	ClientKeyLocator keychain.KeyLocator
+	// HtlcKeys holds all keys used in the swap HTLC construction.
+	HtlcKeys HtlcKeys
 
 	// CltvExpiry is the total absolute CLTV expiry of the swap.
 	CltvExpiry int32

loopdb/loopin.go

@@ -63,15 +63,15 @@ func serializeLoopInContract(swap *LoopInContract) (
 		return nil, err
 	}
 
-	n, err := b.Write(swap.SenderKey[:])
+	n, err := b.Write(swap.HtlcKeys.SenderScriptKey[:])
 	if err != nil {
 		return nil, err
 	}
 	if n != keyLength {
 		return nil, fmt.Errorf("sender key has invalid length")
 	}
 
-	n, err = b.Write(swap.ReceiverKey[:])
+	n, err = b.Write(swap.HtlcKeys.ReceiverScriptKey[:])
 	if err != nil {
 		return nil, err
 	}
@@ -161,15 +161,15 @@ func deserializeLoopInContract(value []byte) (*LoopInContract, error) {
 		return nil, err
 	}
 
-	n, err := r.Read(contract.SenderKey[:])
+	n, err := r.Read(contract.HtlcKeys.SenderScriptKey[:])
 	if err != nil {
 		return nil, err
 	}
 	if n != keyLength {
 		return nil, fmt.Errorf("sender key has invalid length")
 	}
 
-	n, err = r.Read(contract.ReceiverKey[:])
+	n, err = r.Read(contract.HtlcKeys.ReceiverScriptKey[:])
 	if err != nil {
 		return nil, err
 	}

loopdb/loopout.go

@@ -134,15 +134,15 @@ func deserializeLoopOutContract(value []byte, chainParams *chaincfg.Params) (
 		return nil, err
 	}
 
-	n, err := r.Read(contract.SenderKey[:])
+	n, err := r.Read(contract.HtlcKeys.SenderScriptKey[:])
 	if err != nil {
 		return nil, err
 	}
 	if n != keyLength {
 		return nil, fmt.Errorf("sender key has invalid length")
 	}
 
-	n, err = r.Read(contract.ReceiverKey[:])
+	n, err = r.Read(contract.HtlcKeys.ReceiverScriptKey[:])
 	if err != nil {
 		return nil, err
 	}
@@ -229,15 +229,15 @@ func serializeLoopOutContract(swap *LoopOutContract) (
 		return nil, err
 	}
 
-	n, err := b.Write(swap.SenderKey[:])
+	n, err := b.Write(swap.HtlcKeys.SenderScriptKey[:])
 	if err != nil {
 		return nil, err
 	}
 	if n != keyLength {
 		return nil, fmt.Errorf("sender key has invalid length")
 	}
 
-	n, err = b.Write(swap.ReceiverKey[:])
+	n, err = b.Write(swap.HtlcKeys.ReceiverScriptKey[:])
 	if err != nil {
 		return nil, err
 	}

loopdb/protocol_version.go

@@ -68,7 +68,7 @@ const (
 
 	// experimentalRPCProtocolVersion defines the RPC protocol version that
 	// includes all currently experimentally released features.
-	experimentalRPCProtocolVersion = looprpc.ProtocolVersion_HTLC_V3
+	experimentalRPCProtocolVersion = looprpc.ProtocolVersion_MUSIG2
 )
 
 var (

loopdb/store.go

@@ -112,9 +112,30 @@ var (
 	// value: concatenation of uint32 values [family, index].
 	keyLocatorKey = []byte("keylocator")
 
+	// senderInternalPubKeyKey is the key that stores the sender's internal
+	// public key which used when constructing the swap HTLC.
+	//
+	// path: loopInBucket/loopOutBucket -> swapBucket[hash]
+	//                                      -> senderInternalPubKeyKey
+	// value: serialized public key.
+	senderInternalPubKeyKey = []byte("sender-internal-pubkey")
+
+	// receiverInternalPubKeyKey is the key that stores the receiver's
+	// internal public key which is used when constructing the swap HTLC.
+	//
+	// path: loopInBucket/loopOutBucket -> swapBucket[hash]
+	//                                     -> receiverInternalPubKeyKey
+	// value: serialized public key.
+	receiverInternalPubKeyKey = []byte("receiver-internal-pubkey")
+
 	byteOrder = binary.BigEndian
 
+	// keyLength is the length of a serialized public key.
 	keyLength = 33
+
+	// errInvalidKey is returned when a serialized key is not the expected
+	// length.
+	errInvalidKey = fmt.Errorf("invalid serialized key")
 )
 
 const (
@@ -233,6 +254,95 @@ func NewBoltSwapStore(dbPath string, chainParams *chaincfg.Params) (
 	}, nil
 }
 
+// marshalHtlcKeys marshals the HTLC keys of the swap contract into the swap
+// bucket.
+func marshalHtlcKeys(swapBucket *bbolt.Bucket, contract *SwapContract) error {
+	var err error
+
+	// Store the key locator for swaps that use taproot HTLCs.
+	if contract.ProtocolVersion >= ProtocolVersionHtlcV3 {
+		keyLocator, err := MarshalKeyLocator(
+			contract.HtlcKeys.ClientScriptKeyLocator,
+		)
+		if err != nil {
+			return err
+		}
+
+		err = swapBucket.Put(keyLocatorKey, keyLocator)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Store the internal keys for MuSig2 swaps.
+	if contract.ProtocolVersion >= ProtocolVersionMuSig2 {
+		// Internal pubkeys are always filled.
+		err = swapBucket.Put(
+			senderInternalPubKeyKey,
+			contract.HtlcKeys.SenderInternalPubKey[:],
+		)
+		if err != nil {
+			return err
+		}
+
+		err = swapBucket.Put(
+			receiverInternalPubKeyKey,
+			contract.HtlcKeys.ReceiverInternalPubKey[:],
+		)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// unmarshalHtlcKeys deserializes the htlc keys from the swap bucket.
+func unmarshalHtlcKeys(swapBucket *bbolt.Bucket, contract *SwapContract) error {
+	var err error
+
+	// HTLC V3 contracts have the client script key locator stored.
+	if contract.ProtocolVersion >= ProtocolVersionHtlcV3 &&
+		ProtocolVersionUnrecorded > contract.ProtocolVersion {
+
+		contract.HtlcKeys.ClientScriptKeyLocator, err =
+			UnmarshalKeyLocator(
+				swapBucket.Get(keyLocatorKey),
+			)
+		if err != nil {
+			return err
+		}
+
+		// Default the internal scriptkeys to the sender and receiver
+		// keys.
+		contract.HtlcKeys.SenderInternalPubKey =
+			contract.HtlcKeys.SenderScriptKey
+		contract.HtlcKeys.ReceiverInternalPubKey =
+			contract.HtlcKeys.ReceiverScriptKey
+	}
+
+	// MuSig2 contracts have the internal keys stored too.
+	if contract.ProtocolVersion >= ProtocolVersionMuSig2 &&
+		ProtocolVersionUnrecorded > contract.ProtocolVersion {
+
+		// The pubkeys used for the joint HTLC internal key are always
+		// present.
+		key := swapBucket.Get(senderInternalPubKeyKey)
+		if len(key) != keyLength {
+			return errInvalidKey
+		}
+		copy(contract.HtlcKeys.SenderInternalPubKey[:], key)
+
+		key = swapBucket.Get(receiverInternalPubKeyKey)
+		if len(key) != keyLength {
+			return errInvalidKey
+		}
+		copy(contract.HtlcKeys.ReceiverInternalPubKey[:], key)
+	}
+
+	return nil
+}
+
 // FetchLoopOutSwaps returns all loop out swaps currently in the store.
 //
 // NOTE: Part of the loopdb.SwapStore interface.
@@ -435,19 +545,10 @@ func (s *boltSwapStore) CreateLoopOut(hash lntypes.Hash,
 			return err
 		}
 
-		// Store the key locator for swaps with taproot htlc.
-		if swap.ProtocolVersion >= ProtocolVersionHtlcV3 {
-			keyLocator, err := MarshalKeyLocator(
-				swap.ClientKeyLocator,
-			)
-			if err != nil {
-				return err
-			}
-
-			err = swapBucket.Put(keyLocatorKey, keyLocator)
-			if err != nil {
-				return err
-			}
+		// Store the htlc keys and server key locator.
+		err = marshalHtlcKeys(swapBucket, &swap.SwapContract)
+		if err != nil {
+			return err
 		}
 
 		// Finally, we'll create an empty updates bucket for this swap
@@ -501,19 +602,10 @@ func (s *boltSwapStore) CreateLoopIn(hash lntypes.Hash,
 			return err
 		}
 
-		// Store the key locator for swaps with taproot htlc.
-		if swap.ProtocolVersion >= ProtocolVersionHtlcV3 {
-			keyLocator, err := MarshalKeyLocator(
-				swap.ClientKeyLocator,
-			)
-			if err != nil {
-				return err
-			}
-
-			err = swapBucket.Put(keyLocatorKey, keyLocator)
-			if err != nil {
-				return err
-			}
+		// Store the htlc keys and server key locator.
+		err = marshalHtlcKeys(swapBucket, &swap.SwapContract)
+		if err != nil {
+			return err
 		}
 
 		// Finally, we'll create an empty updates bucket for this swap
@@ -788,14 +880,12 @@ func (s *boltSwapStore) fetchLoopOutSwap(rootBucket *bbolt.Bucket,
 		return nil, err
 	}
 
-	// Try to unmarshal the key locator.
-	if contract.ProtocolVersion >= ProtocolVersionHtlcV3 {
-		contract.ClientKeyLocator, err = UnmarshalKeyLocator(
-			swapBucket.Get(keyLocatorKey),
-		)
-		if err != nil {
-			return nil, err
-		}
+	// Unmarshal HTLC keys if the contract is recent.
+	err = unmarshalHtlcKeys(
+		swapBucket, &contract.SwapContract,
+	)
+	if err != nil {
+		return nil, err
 	}
 
 	loop := LoopOut{
@@ -865,14 +955,12 @@ func (s *boltSwapStore) fetchLoopInSwap(rootBucket *bbolt.Bucket,
 		return nil, err
 	}
 
-	// Try to unmarshal the key locator.
-	if contract.ProtocolVersion >= ProtocolVersionHtlcV3 {
-		contract.ClientKeyLocator, err = UnmarshalKeyLocator(
-			swapBucket.Get(keyLocatorKey),
-		)
-		if err != nil {
-			return nil, err
-		}
+	// Unmarshal HTLC keys if the contract is recent.
+	err = unmarshalHtlcKeys(
+		swapBucket, &contract.SwapContract,
+	)
+	if err != nil {
+		return nil, err
 	}
 
 	loop := LoopIn{