tapgarden: implement SealBatch

Author: jharveyb

tapgarden/planter.go

@@ -1000,9 +1000,32 @@ func (c *ChainPlanter) gardener() {
 
 				req.Resolve(c.pendingBatch)
 
-			// TODO(jhb): follow-up PR: Implement SealBatch command
 			case reqTypeSealBatch:
-				req.Error(fmt.Errorf("not yet implemented"))
+				if c.pendingBatch == nil {
+					req.Error(fmt.Errorf("no pending batch"))
+					break
+				}
+
+				sealReqParams, err :=
+					typedParam[SealParams](req)
+				if err != nil {
+					req.Error(fmt.Errorf("bad seal "+
+						"params: %w", err))
+					break
+				}
+
+				ctx, cancel := c.WithCtxQuit()
+				sealedBatch, err := c.sealBatch(
+					ctx, *sealReqParams,
+				)
+				cancel()
+				if err != nil {
+					req.Error(fmt.Errorf("unable to seal"+
+						"minting batch: %w", err))
+					break
+				}
+
+				req.Resolve(sealedBatch)
 
 			case reqTypeFinalizeBatch:
 				if c.pendingBatch == nil {
@@ -1192,27 +1215,24 @@ func (c *ChainPlanter) fundBatch(ctx context.Context, params FundParams) error {
 // possible if they are not provided. After all asset group witnesses have been
 // validated, they are saved to disk to be used by the caretaker during batch
 // finalization.
-func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error {
+func (c *ChainPlanter) sealBatch(ctx context.Context,
+	params SealParams) (*MintingBatch, error) {
 	// A batch should exist with 1+ seedlings and be funded before being
 	// sealed.
-	if c.pendingBatch == nil {
-		return fmt.Errorf("no pending batch")
-	}
-
-	if len(c.pendingBatch.Seedlings) == 0 {
-		return fmt.Errorf("no seedlings in batch")
+	if !c.pendingBatch.HasSeedlings() {
+		return nil, fmt.Errorf("no seedlings in batch")
 	}
 
 	if !c.pendingBatch.IsFunded() {
-		return fmt.Errorf("batch is not funded")
+		return nil, fmt.Errorf("batch is not funded")
 	}
 
 	// Filter the batch seedlings to only consider those that will become
 	// grouped assets. If there are no such seedlings, then there is nothing
 	// to seal and no action is needed.
 	groupSeedlings, _ := filterSeedlingsWithGroup(c.pendingBatch.Seedlings)
 	if len(groupSeedlings) == 0 {
-		return nil
+		return c.pendingBatch, nil
 	}
 
 	// Before we can build the group key requests for each seedling, we must
@@ -1229,23 +1249,61 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error {
 	// Construct the group key requests and group virtual TXs for each
 	// seedling. With these we can verify provided asset group witnesses,
 	// or attempt to derive asset group witnesses if needed.
-	groupReqs, genTXs, err := c.buildGroupReqs(
-		genesisPoint, anchorOutputIndex, groupSeedlings,
+	groupReqs, genTXs, err := buildGroupReqs(
+		genesisPoint, anchorOutputIndex, c.cfg.GenTxBuilder,
+		groupSeedlings,
 	)
 	if err != nil {
-		return fmt.Errorf("unable to build group requests: %w", err)
+		return nil, fmt.Errorf("unable to build group requests: "+
+			"%w", err)
+	}
+
+	// TODO: check for previous batch sealing
+	// Each provided asset group witness must have a corresponding seedling
+	// in the current batch.
+	seedlingAssetIDs := fn.NewSet(
+		fn.Map(groupReqs, func(req asset.GroupKeyRequest) asset.ID {
+			return req.NewAsset.ID()
+		})...,
+	)
+	externalWitnesses := make(map[asset.ID]groupSeal)
+	for _, seal := range params.GroupWitnesses {
+		if !seedlingAssetIDs.Contains(seal.GroupMember) {
+			return nil, fmt.Errorf("witness has no matching "+
+				"seedling: %v", seal)
+		}
+		externalWitnesses[seal.GroupMember] = seal
 	}
 
 	assetGroups := make([]*asset.AssetGroup, 0, len(groupReqs))
 	for i := 0; i < len(groupReqs); i++ {
-		// Derive the asset group witness.
-		groupKey, err := asset.DeriveGroupKey(
-			c.cfg.GenSigner, genTXs[i], groupReqs[i], nil,
+		var (
+			groupKey *asset.GroupKey
+			err      error
 		)
-		if err != nil {
-			return err
-		}
 
+		reqAssetID := groupReqs[i].NewAsset.ID()
+		groupWitness, ok := externalWitnesses[reqAssetID]
+
+		switch {
+		case ok:
+			// Set the provided witness; it will be validated below.
+			groupKey = &asset.GroupKey{
+				RawKey:        groupReqs[i].RawKey,
+				GroupPubKey:   genTXs[i].TweakedKey,
+				TapscriptRoot: groupReqs[i].TapscriptRoot,
+				Witness:       groupWitness.GroupWitness,
+			}
+
+		default:
+			// Derive the asset group witness.
+			groupKey, err = asset.DeriveGroupKey(
+				c.cfg.GenSigner, genTXs[i], groupReqs[i], nil,
+			)
+			if err != nil {
+				return nil, err
+			}
+		}
 		// Recreate the asset with the populated group key and validate
 		// the asset group witness.
 		protoAsset := groupReqs[i].NewAsset
@@ -1256,12 +1314,12 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error {
 			asset.WithAssetVersion(protoAsset.Version),
 		)
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		err = c.cfg.TxValidator.Execute(groupedAsset, nil, nil)
 		if err != nil {
-			return fmt.Errorf("unable to verify asset "+
+			return nil, fmt.Errorf("unable to verify asset "+
 				"group witness: %w", err)
 		}
 
@@ -1277,10 +1335,11 @@ func (c *ChainPlanter) sealBatch(ctx context.Context, _ SealParams) error {
 	// to disk.
 	err = c.cfg.Log.AddSeedlingGroups(ctx, genesisPoint, assetGroups)
 	if err != nil {
-		return fmt.Errorf("unable to write seedling groups: %w", err)
+		return nil, fmt.Errorf("unable to write seedling groups: "+
+		"%w", err)
 	}
 
-	return nil
+	return c.pendingBatch, nil
 }
 
 // finalizeBatch creates a new caretaker for the batch and starts it.
@@ -1336,8 +1395,10 @@ func (c *ChainPlanter) finalizeBatch(params FinalizeParams) (*BatchCaretaker,
 		}
 	}
 
-	// TODO(jhb): follow-up PR: detect batches that were already sealed
-	err = c.sealBatch(ctx, SealParams{})
+	// If the batch needs to be sealed, we'll use the default behavior for
+	// generating asset group witnesses. Any custom behavior requires
+	// calling SealBatch() explicitly, before batch finalization.
+	_, err = c.sealBatch(ctx, SealParams{})
 	if err != nil {
 		return nil, err
 	}