Merge pull request #1655 from lightninglabs/wip/supplycommit/bugfix-state-machine

Bugfix supply commit state machine

Author: Roasbeef

tapdb/sqlc/querier.go

@@ -137,9 +137,11 @@ DELETE FROM supply_update_events
 WHERE transition_id = @transition_id;
 
 -- name: FetchUnspentPrecommits :many
+-- Fetch unspent pre-commitment outputs. A pre-commitment output is a mint
+-- anchor transaction output which relates to the supply commitment feature.
 SELECT
     mac.tx_output_index,
-    ik.raw_key AS taproot_internal_key,
+    sqlc.embed(ik),
     mac.group_key,
     mint_txn.block_height,
     mint_txn.raw_tx
@@ -159,7 +161,7 @@ SELECT
     sc.commit_id,
     sc.output_index,
     sc.output_key,
-    ik.raw_key AS internal_key,
+    sqlc.embed(ik),
     txn.raw_tx,
     sc.supply_root_hash AS root_hash,
     sc.supply_root_sum AS root_sum 

tapdb/sqlc/queries/supply_commit.sql

@@ -245,12 +245,10 @@ func (s *SupplyCommitMachine) UnspentPrecommits(ctx context.Context,
 		// interface.
 		preCommits = make(supplycommit.PreCommits, 0, len(rows))
 		for _, row := range rows {
-			internalKey, err := btcec.ParsePubKey(
-				row.TaprootInternalKey,
-			)
+			internalKey, err := parseInternalKey(row.InternalKey)
 			if err != nil {
-				return fmt.Errorf("error parsing internal "+
-					"key: %w", err)
+				return fmt.Errorf("failed to parse "+
+					"pre-commitment internal key: %w", err)
 			}
 
 			groupPubKey, err := btcec.ParsePubKey(row.GroupKey)
@@ -272,7 +270,7 @@ func (s *SupplyCommitMachine) UnspentPrecommits(ctx context.Context,
 				),
 				MintingTxn:  &mintingTx,
 				OutIdx:      uint32(row.TxOutputIndex),
-				InternalKey: *internalKey,
+				InternalKey: internalKey,
 				GroupPubKey: *groupPubKey,
 			}
 			preCommits = append(preCommits, preCommit)
@@ -315,7 +313,7 @@ func (s *SupplyCommitMachine) SupplyCommit(ctx context.Context,
 				err)
 		}
 
-		internalKey, err := btcec.ParsePubKey(row.InternalKey)
+		internalKey, err := parseInternalKey(row.InternalKey)
 		if err != nil {
 			return fmt.Errorf("error parsing internal key: %w", err)
 		}
@@ -828,7 +826,11 @@ func fetchCommitment(ctx context.Context, db SupplyCommitStore,
 			"fetch internal key %d for commit %d: %w",
 			commit.InternalKeyID, commitID.Int64, err)
 	}
-	internalKey, err := btcec.ParsePubKey(internalKeyRow.RawKey)
+	internalKey, err := parseInternalKey(sqlc.InternalKey{
+		RawKey:    internalKeyRow.RawKey,
+		KeyFamily: internalKeyRow.KeyFamily,
+		KeyIndex:  internalKeyRow.KeyIndex,
+	})
 	if err != nil {
 		return noneRootCommit, noneChainInfo, fmt.Errorf("failed to "+
 			"parse internal key for commit %d: %w", commitID.Int64,

tapdb/sqlc/supply_commit.sql.go

@@ -681,15 +681,15 @@ func (h *supplyCommitTestHarness) performSingleTransition(
 	// Next, we'll generate a new "fake" commitment transaction along with
 	// sample internal and output keys.
 	commitTx := randTx(h.t, 1)
-	internalKey := test.RandPubKey(h.t)
+	internalKey, _ := test.RandKeyDesc(h.t)
 	outputKey := test.RandPubKey(h.t)
 
 	// We'll now simulate the next phase of the state transition where we
 	// make the new commitment, capture that in a new commit tx, then sign
 	// and commit that.
 	commitDetails := supplycommit.SupplyCommitTxn{
 		Txn:         commitTx,
-		InternalKey: internalKey,
+		InternalKey: internalKey.PubKey,
 		OutputKey:   outputKey,
 		OutputIndex: 1,
 	}
@@ -764,7 +764,7 @@ func (h *supplyCommitTestHarness) performSingleTransition(
 
 	return stateTransitionOutput{
 		appliedUpdates: updates,
-		internalKey:    internalKey,
+		internalKey:    internalKey.PubKey,
 		outputKey:      outputKey,
 		commitTx:       commitTx,
 		chainProof:     chainProof,
@@ -1116,7 +1116,7 @@ func (h *supplyCommitTestHarness) assertTransitionApplied(
 	)
 	require.Equal(
 		h.t, output.internalKey.SerializeCompressed(),
-		fetchedCommit.InternalKey.SerializeCompressed(),
+		fetchedCommit.InternalKey.PubKey.SerializeCompressed(),
 		"SupplyCommit returned wrong InternalKey",
 	)
 	require.Equal(
@@ -1321,7 +1321,7 @@ func TestSupplyCommitInsertSignedCommitTx(t *testing.T) {
 	)
 	require.Equal(
 		t, internalKey.SerializeCompressed(),
-		fetchedTransition.NewCommitment.InternalKey.SerializeCompressed(), //nolint:lll
+		fetchedTransition.NewCommitment.InternalKey.PubKey.SerializeCompressed(), //nolint:lll
 	)
 	require.Equal(
 		t, outputKey.SerializeCompressed(),
@@ -1714,7 +1714,7 @@ func TestSupplyCommitMachineFetch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(
 		t, dbInternalKeyRow.RawKey,
-		rootCommit.InternalKey.SerializeCompressed(),
+		rootCommit.InternalKey.PubKey.SerializeCompressed(),
 	)
 	require.Equal(
 		t, dbCommit.OutputKey,

tapdb/supply_commit.go

@@ -123,7 +123,7 @@ type PreCommitment struct {
 
 	// InternalKey is the Taproot internal public key associated with the
 	// pre-commitment output.
-	InternalKey btcec.PublicKey
+	InternalKey keychain.KeyDescriptor
 
 	// GroupPubKey is the asset group public key associated with this
 	// pre-commitment output.
@@ -154,7 +154,7 @@ type RootCommitment struct {
 	TxOutIdx uint32
 
 	// InternalKey is the internal key used to create the commitment output.
-	InternalKey *btcec.PublicKey
+	InternalKey keychain.KeyDescriptor
 
 	// Output key is the taproot output key used to create the commitment
 	// output.
@@ -182,11 +182,21 @@ func (r *RootCommitment) TxIn() *wire.TxIn {
 //
 // TODO(roasbeef): expand, add support for tapscript as well
 func (r *RootCommitment) TxOut() (*wire.TxOut, error) {
-	// First, obtain the root hash of the supply tree.
-	supplyRootHash := r.SupplyRoot.NodeHash()
+	txOut, _, err := RootCommitTxOut(
+		r.InternalKey.PubKey, r.OutputKey, r.SupplyRoot.NodeHash(),
+	)
+
+	return txOut, err
+}
 
-	var taprootKey *btcec.PublicKey
-	if r.OutputKey == nil {
+// RootCommitTxOut returns the transaction output that corresponds to the root
+// commitment. This is used to create a new commitment output.
+func RootCommitTxOut(internalKey *btcec.PublicKey,
+	tapOutKey *btcec.PublicKey, supplyRootHash mssmt.NodeHash) (*wire.TxOut,
+	*btcec.PublicKey, error) {
+
+	var taprootOutputKey *btcec.PublicKey
+	if tapOutKey == nil {
 		// We'll create a new unspendable output that contains a
 		// commitment to the root.
 		//
@@ -195,28 +205,32 @@ func (r *RootCommitment) TxOut() (*wire.TxOut, error) {
 			asset.PedersenVersion, supplyRootHash[:],
 		)
 		if err != nil {
-			return nil, fmt.Errorf("unable to create leaf: %w", err)
+			return nil, nil, fmt.Errorf("unable to create leaf: %w",
+				err)
 		}
 
 		tapscriptTree := txscript.AssembleTaprootScriptTree(tapLeaf)
 
 		rootHash := tapscriptTree.RootNode.TapHash()
-		taprootKey = txscript.ComputeTaprootOutputKey(
-			r.InternalKey, rootHash[:],
+		taprootOutputKey = txscript.ComputeTaprootOutputKey(
+			internalKey, rootHash[:],
 		)
 	} else {
-		taprootKey = r.OutputKey
+		taprootOutputKey = tapOutKey
 	}
 
-	pkScript, err := txscript.PayToTaprootScript(taprootKey)
+	pkScript, err := txscript.PayToTaprootScript(taprootOutputKey)
 	if err != nil {
-		return nil, fmt.Errorf("unable to create pk script: %w", err)
+		return nil, nil, fmt.Errorf("unable to create pk script: %w",
+			err)
 	}
 
-	return &wire.TxOut{
+	txOut := wire.TxOut{
 		Value:    int64(tapsend.DummyAmtSats),
 		PkScript: pkScript,
-	}, nil
+	}
+
+	return &txOut, taprootOutputKey, nil
 }
 
 // ChainProof stores the information needed to prove that a given supply commit
@@ -293,9 +307,8 @@ type Wallet interface {
 		feeRate chainfee.SatPerKWeight,
 		changeIdx int32) (*tapsend.FundedPsbt, error)
 
-	// SignAndFinalizePsbt fully signs and finalizes the target PSBT
-	// packet.
-	SignAndFinalizePsbt(context.Context, *psbt.Packet) (*psbt.Packet, error)
+	// SignPsbt fully signs the target PSBT packet.
+	SignPsbt(context.Context, *psbt.Packet) (*psbt.Packet, error)
 
 	// ImportTaprootOutput imports a new taproot output key into the wallet.
 	ImportTaprootOutput(context.Context, *btcec.PublicKey) (btcutil.Address,

tapdb/supply_commit_test.go

@@ -75,11 +75,9 @@ type fundPsbtMockFn func(
 	chainfee.SatPerKWeight, int32,
 ) (*tapsend.FundedPsbt, error)
 
-// signAndFinalizePsbtMockFn defines a type for the mock function used in
+// signPsbtMockFn defines a type for the mock function used in
 // SignAndFinalizePsbt, to simplify a long type assertion.
-type signAndFinalizePsbtMockFn func(
-	context.Context, *psbt.Packet,
-) (*psbt.Packet, error)
+type signPsbtMockFn func(context.Context, *psbt.Packet) (*psbt.Packet, error)
 
 // mockWallet is a mock implementation of the Wallet interface.
 type mockWallet struct {
@@ -107,7 +105,7 @@ func (m *mockWallet) FundPsbt(
 	return args.Get(0).(*tapsend.FundedPsbt), args.Error(1)
 }
 
-func (m *mockWallet) SignAndFinalizePsbt(ctx context.Context,
+func (m *mockWallet) SignPsbt(ctx context.Context,
 	packet *psbt.Packet) (*psbt.Packet, error) {
 
 	args := m.Called(ctx, packet)
@@ -116,7 +114,7 @@ func (m *mockWallet) SignAndFinalizePsbt(ctx context.Context,
 	// If so, this indicates a custom mock implementation that should be
 	// executed to get the actual return values.
 	arg0 := args.Get(0)
-	if fn, ok := arg0.(signAndFinalizePsbtMockFn); ok {
+	if fn, ok := arg0.(signPsbtMockFn); ok {
 		return fn(ctx, packet)
 	}
 

universe/supplycommit/env.go

@@ -418,7 +418,7 @@ func (h *supplyCommitTestHarness) expectPsbtFunding() {
 }
 
 func (h *supplyCommitTestHarness) expectPsbtSigning() {
-	signFn := signAndFinalizePsbtMockFn(func(
+	signFn := signPsbtMockFn(func(
 		_ context.Context, pkt *psbt.Packet,
 	) (*psbt.Packet, error) {
 		// The transaction from the PSBT is extracted and used to create
@@ -428,7 +428,7 @@ func (h *supplyCommitTestHarness) expectPsbtSigning() {
 		return newTestSignedPsbt(h.t, pkt.UnsignedTx), nil
 	})
 	h.mockWallet.On(
-		"SignAndFinalizePsbt", mock.Anything, mock.Anything,
+		"SignPsbt", mock.Anything, mock.Anything,
 	).Return(signFn, nil).Once()
 }
 
@@ -791,10 +791,13 @@ func TestSupplyCommitTxSignStateTransitions(t *testing.T) {
 	defaultAssetSpec := asset.NewSpecifierFromId(testAssetID)
 	dummyTx := wire.NewMsgTx(2)
 	dummyTx.AddTxOut(&wire.TxOut{PkScript: []byte("test"), Value: 1})
+
+	internalKey, _ := test.RandKeyDesc(t)
+
 	initialTransition := SupplyStateTransition{
 		NewCommitment: RootCommitment{
 			Txn:         dummyTx,
-			InternalKey: test.RandPubKey(t),
+			InternalKey: internalKey,
 			TxOutIdx:    0,
 		},
 	}