multi: validate and insert supply commit into universe

Author: guggero

proof/util.go

@@ -45,9 +45,9 @@ func unpackBits(bytes []byte) []bool {
 	return bits
 }
 
-// txSpendsPrevOut returns whether the given prevout is spent by the given
+// TxSpendsPrevOut returns whether the given prevout is spent by the given
 // transaction.
-func txSpendsPrevOut(tx *wire.MsgTx, prevOut *wire.OutPoint) bool {
+func TxSpendsPrevOut(tx *wire.MsgTx, prevOut *wire.OutPoint) bool {
 	for _, txIn := range tx.TxIn {
 		if txIn.PreviousOutPoint == *prevOut {
 			return true

proof/verifier.go

@@ -877,7 +877,7 @@ func (p *Proof) Verify(ctx context.Context, prev *AssetSnapshot,
 		return nil, fmt.Errorf("%w: prev output mismatch",
 			commitment.ErrInvalidTaprootProof)
 	}
-	if !txSpendsPrevOut(&p.AnchorTx, &p.PrevOut) {
+	if !TxSpendsPrevOut(&p.AnchorTx, &p.PrevOut) {
 		return nil, fmt.Errorf("%w: doesn't spend prev output",
 			commitment.ErrInvalidTaprootProof)
 	}

rpcserver.go

@@ -4476,34 +4476,32 @@ func (r *rpcServer) FetchSupplyLeaves(ctx context.Context,
 // both a supplycommit.RootCommitment and supplycommit.ChainProof.
 func unmarshalSupplyCommitChainData(
 	rpcData *unirpc.SupplyCommitChainData) (*supplycommit.RootCommitment,
-	*supplycommit.ChainProof, error) {
+	error) {
 
 	if rpcData == nil {
-		return nil, nil, fmt.Errorf("supply commit chain data is nil")
+		return nil, fmt.Errorf("supply commit chain data is nil")
 	}
 
 	var txn wire.MsgTx
 	err := txn.Deserialize(bytes.NewReader(rpcData.Txn))
 	if err != nil {
-		return nil, nil, fmt.Errorf("unable to deserialize "+
-			"transaction: %w", err)
+		return nil, fmt.Errorf("unable to deserialize transaction: %w",
+			err)
 	}
 
 	internalKey, err := btcec.ParsePubKey(rpcData.InternalKey)
 	if err != nil {
-		return nil, nil, fmt.Errorf("unable to parse internal key: %w",
-			err)
+		return nil, fmt.Errorf("unable to parse internal key: %w", err)
 	}
 
 	outputKey, err := btcec.ParsePubKey(rpcData.OutputKey)
 	if err != nil {
-		return nil, nil, fmt.Errorf("unable to parse output key: %w",
-			err)
+		return nil, fmt.Errorf("unable to parse output key: %w", err)
 	}
 
 	// Convert supply root hash.
 	if len(rpcData.SupplyRootHash) != 32 {
-		return nil, nil, fmt.Errorf("invalid supply root hash size: "+
+		return nil, fmt.Errorf("invalid supply root hash size: "+
 			"expected %d, got %d", 32, len(rpcData.SupplyRootHash))
 	}
 	var supplyRootHash mssmt.NodeHash
@@ -4513,7 +4511,7 @@ func unmarshalSupplyCommitChainData(
 	var commitmentBlock fn.Option[supplycommit.CommitmentBlock]
 	if len(rpcData.BlockHash) > 0 {
 		if len(rpcData.BlockHash) != chainhash.HashSize {
-			return nil, nil, fmt.Errorf("invalid block hash size: "+
+			return nil, fmt.Errorf("invalid block hash size: "+
 				"expected %d, got %d", chainhash.HashSize,
 				len(rpcData.BlockHash))
 		}
@@ -4543,25 +4541,25 @@ func unmarshalSupplyCommitChainData(
 	var blockHeader wire.BlockHeader
 	err = blockHeader.Deserialize(bytes.NewReader(rpcData.BlockHeader))
 	if err != nil {
-		return nil, nil, fmt.Errorf("unable to deserialize block "+
-			"header: %w", err)
+		return nil, fmt.Errorf("unable to deserialize block header: "+
+			"%w", err)
 	}
 
 	var merkleProof proof.TxMerkleProof
 	err = merkleProof.Decode(bytes.NewReader(rpcData.TxBlockMerkleProof))
 	if err != nil {
-		return nil, nil, fmt.Errorf("unable to decode merkle proof: %w",
-			err)
+		return nil, fmt.Errorf("unable to decode merkle proof: %w", err)
 	}
 
-	chainProof := &supplycommit.ChainProof{
-		Header:      blockHeader,
-		BlockHeight: rpcData.BlockHeight,
-		MerkleProof: merkleProof,
+	rootCommitment.CommitmentBlock = fn.Some(supplycommit.CommitmentBlock{
+		Height:      rpcData.BlockHeight,
+		Hash:        blockHeader.BlockHash(),
 		TxIndex:     rpcData.TxIndex,
-	}
+		BlockHeader: &blockHeader,
+		MerkleProof: &merkleProof,
+	})
 
-	return rootCommitment, chainProof, nil
+	return rootCommitment, nil
 }
 
 // InsertSupplyCommit stores a verified supply commitment for the given
@@ -4582,14 +4580,24 @@ func (r *rpcServer) InsertSupplyCommit(ctx context.Context,
 		groupPubKey.SerializeCompressed())
 
 	// Unmarshal the supply commit chain data.
-	rootCommitment, chainProof, err := unmarshalSupplyCommitChainData(
-		req.ChainData,
-	)
+	rootCommitment, err := unmarshalSupplyCommitChainData(req.ChainData)
 	if err != nil {
 		return nil, fmt.Errorf("failed to unmarshal chain data: %w",
 			err)
 	}
 
+	if req.SpentCommitmentOutpoint != nil {
+		op, err := rpcutils.UnmarshalOutPoint(
+			req.SpentCommitmentOutpoint,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse spent "+
+				"commitment outpoint: %w", err)
+		}
+
+		rootCommitment.SpentCommitment = fn.Some(op)
+	}
+
 	supplyLeaves, err := unmarshalSupplyLeaves(
 		req.IssuanceLeaves, req.BurnLeaves, req.IgnoreLeaves,
 	)
@@ -4606,7 +4614,7 @@ func (r *rpcServer) InsertSupplyCommit(ctx context.Context,
 
 	assetSpec := asset.NewSpecifierFromGroupKey(*groupPubKey)
 	err = r.cfg.SupplyVerifyManager.InsertSupplyCommit(
-		ctx, assetSpec, *rootCommitment, *supplyLeaves, *chainProof,
+		ctx, assetSpec, *rootCommitment, *supplyLeaves,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("failed to insert supply commitment: %w",

tapdb/supply_commit.go

@@ -901,6 +901,198 @@ func (s *SupplyCommitMachine) InsertSignedCommitTx(ctx context.Context,
 	})
 }
 
+// InsertSupplyCommit inserts a new, fully complete supply commitment into the
+// database.
+func (s *SupplyCommitMachine) InsertSupplyCommit(ctx context.Context,
+	assetSpec asset.Specifier, commit supplycommit.RootCommitment,
+	leaves supplycommit.SupplyLeaves) error {
+
+	groupKey := assetSpec.UnwrapGroupKeyToPtr()
+	if groupKey == nil {
+		return ErrMissingGroupKey
+	}
+	groupKeyBytes := groupKey.SerializeCompressed()
+
+	commitTx := commit.Txn
+	internalKey := commit.InternalKey
+	outputKey := commit.OutputKey
+	outputIndex := commit.TxOutIdx
+
+	block, err := commit.CommitmentBlock.UnwrapOrErr(
+		supplycommit.ErrNoBlockInfo,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to unwrap commitment block: %w", err)
+	}
+
+	writeTx := WriteTxOption()
+	return s.db.ExecTx(ctx, writeTx, func(db SupplyCommitStore) error {
+		// Next, we'll upsert the chain transaction on disk. The block
+		// related fields are nil as this hasn't been confirmed yet.
+		var txBytes bytes.Buffer
+		if err := commitTx.Serialize(&txBytes); err != nil {
+			return fmt.Errorf("failed to serialize commit "+
+				"tx: %w", err)
+		}
+		txid := commitTx.TxHash()
+		chainTxID, err := db.UpsertChainTx(ctx, UpsertChainTxParams{
+			Txid:  txid[:],
+			RawTx: txBytes.Bytes(),
+		})
+		if err != nil {
+			return fmt.Errorf("failed to upsert commit chain tx: "+
+				"%w", err)
+		}
+
+		// Upsert the internal key to get its ID. We assume key family
+		// and index 0 for now, as this key is likely externally.
+		internalKeyID, err := db.UpsertInternalKey(ctx, InternalKey{
+			RawKey:    internalKey.PubKey.SerializeCompressed(),
+			KeyFamily: int32(internalKey.Family),
+			KeyIndex:  int32(internalKey.Index),
+		})
+		if err != nil {
+			return fmt.Errorf("failed to upsert internal key %x: "+
+				"%w", internalKey.PubKey.SerializeCompressed(),
+				err)
+		}
+
+		// Now we fetch the previous commitment that is being spent by
+		// this one.
+		var spentCommitment sql.NullInt64
+		err = fn.MapOptionZ(
+			commit.SpentCommitment, func(op wire.OutPoint) error {
+				q := sqlc.QuerySupplyCommitmentByOutpointParams{
+					GroupKey:    groupKeyBytes,
+					Txid:        op.Hash[:],
+					OutputIndex: sqlInt32(op.Index),
+				}
+				row, err := db.QuerySupplyCommitmentByOutpoint(
+					ctx, q,
+				)
+				if err != nil {
+					return fmt.Errorf("failed to query "+
+						"spent commitment: %w", err)
+				}
+
+				spentCommitment = sqlInt64(
+					row.SupplyCommitment.CommitID,
+				)
+
+				return nil
+			},
+		)
+
+		// Insert the new commitment record. Chain details (block
+		// height, header, proof, output index) are NULL at this stage.
+		newCommitmentID, err := db.InsertSupplyCommitment(
+			//nolint:lll
+			ctx, sqlc.InsertSupplyCommitmentParams{
+				GroupKey:        groupKeyBytes,
+				ChainTxnID:      chainTxID,
+				InternalKeyID:   internalKeyID,
+				OutputKey:       outputKey.SerializeCompressed(),
+				SupplyRootHash:  nil,
+				SupplyRootSum:   sql.NullInt64{},
+				OutputIndex:     sqlInt32(outputIndex),
+				SpentCommitment: spentCommitment,
+			},
+		)
+		if err != nil {
+			return fmt.Errorf("failed to insert new supply "+
+				"commitment: %w", err)
+		}
+
+		// Update the commitment record with the calculated root hash
+		// and sum.
+		finalRootSupplyRoot, err := applySupplyUpdatesInternal(
+			ctx, db, assetSpec, leaves.AllUpdates(),
+		)
+		if err != nil {
+			return fmt.Errorf("failed to apply SMT updates: "+
+				"%w", err)
+		}
+		finalRootHash := finalRootSupplyRoot.NodeHash()
+		finalRootSum := finalRootSupplyRoot.NodeSum()
+		err = db.UpdateSupplyCommitmentRoot(
+			ctx, UpdateSupplyCommitmentRootParams{
+				CommitID:       newCommitmentID,
+				SupplyRootHash: finalRootHash[:],
+				SupplyRootSum:  sqlInt64(int64(finalRootSum)),
+			},
+		)
+		if err != nil {
+			return fmt.Errorf("failed to update commitment root "+
+				"hash/sum for commit %d: %w",
+				newCommitmentID, err)
+		}
+
+		// Next, we'll serialize the merkle proofs and block header, so
+		// we can update them on disk.
+		var (
+			proofBuf  bytes.Buffer
+			headerBuf bytes.Buffer
+		)
+
+		err = block.MerkleProof.Encode(&proofBuf)
+		if err != nil {
+			return fmt.Errorf("failed to encode "+
+				"merkle proof: %w", err)
+		}
+		err = block.BlockHeader.Serialize(&headerBuf)
+		if err != nil {
+			return fmt.Errorf("failed to "+
+				"serialize block header: %w",
+				err)
+		}
+		blockHeight := sqlInt32(block.Height)
+
+		// With all the information serialized above, we'll now update
+		// the chain proof information for this current supply commit.
+		err = db.UpdateSupplyCommitmentChainDetails(
+			ctx, SupplyCommitChainDetails{
+				CommitID:    newCommitmentID,
+				MerkleProof: proofBuf.Bytes(),
+				OutputIndex: sqlInt32(commit.TxOutIdx),
+				BlockHeader: headerBuf.Bytes(),
+				ChainTxnID:  chainTxID,
+				BlockHeight: blockHeight,
+			},
+		)
+		if err != nil {
+			return fmt.Errorf("failed to update commitment chain "+
+				"details: %w", err)
+		}
+
+		// Also update the chain_txns record itself with the
+		// confirmation details (block hash, height, index).
+		var commitTxBytes bytes.Buffer
+		err = commit.Txn.Serialize(&commitTxBytes)
+		if err != nil {
+			return fmt.Errorf("failed to serialize commit tx for "+
+				"update: %w", err)
+		}
+		commitTxid := commit.Txn.TxHash()
+
+		_, err = db.UpsertChainTx(ctx, UpsertChainTxParams{
+			Txid:      commitTxid[:],
+			RawTx:     commitTxBytes.Bytes(),
+			ChainFees: 0,
+			BlockHash: lnutils.ByteSlice(
+				block.BlockHeader.BlockHash(),
+			),
+			BlockHeight: blockHeight,
+			TxIndex:     sqlInt32(block.TxIndex),
+		})
+		if err != nil {
+			return fmt.Errorf("failed to update chain_txns "+
+				"confirmation: %w", err)
+		}
+
+		return nil
+	})
+}
+
 // CommitState commits the state of the state machine to disk.
 func (s *SupplyCommitMachine) CommitState(ctx context.Context,
 	assetSpec asset.Specifier, state supplycommit.State) error {