tapchannel: create 2nd lvl vPkts in resolveContract

With all the prior commits in place, we can now create the new contract
resolution that includes the 1st and 2nd level packets, and the
information that we'll need to re-sign the second level packets later.

Author: Roasbeef

tapchannel/aux_sweeper.go

@@ -1106,6 +1106,7 @@ func deriveCommitKeys(req lnwallet.ResolutionReq) (*asset.ScriptKey,
 // importCommitScriptKeys imports the script keys for the commitment outputs
 // into the local addr book.
 func (a *AuxSweeper) importCommitScriptKeys(req lnwallet.ResolutionReq) error {
+
 	// Generate the local and remote script key, so we can properly import
 	// into the addr book, like we did above.
 	localCommitScriptKey, remoteCommitScriptKey, err := deriveCommitKeys(
@@ -1680,35 +1681,93 @@ func (a *AuxSweeper) resolveContract(
 	log.Infof("Sweeping %v asset outputs: %v", len(assetOutputs),
 		limitSpewer.Sdump(assetOutputs))
 
-	firstLevelSweepDesc := lfn.AndThen(
-		sweepDesc,
-		func(sweepDesc tapscriptSweepDescs) lfn.Result[tapscriptSweepDesc] { //nolint:lll
-			return lfn.Ok(sweepDesc.firstLevel)
-		},
-	)
+	tapSweepDesc, err := sweepDesc.Unpack()
+	if err != nil {
+		return lfn.Err[tlv.Blob](err)
+	}
 
-	// With the sweep desc constructed above, we'll create vPackets for
-	// each of the local assets, then sign them all.
-	sPkts := a.createAndSignSweepVpackets(
-		assetOutputs, req, firstLevelSweepDesc,
+	// With the sweep desc constructed above, we'll create vPackets for each
+	// of the local assets, then sign them all.
+	firstLevelPkts, err := a.createAndSignSweepVpackets(
+		assetOutputs, req, lfn.Ok(tapSweepDesc.firstLevel),
+	).Unpack()
+	if err != nil {
+		return lfn.Err[tlv.Blob](err)
+	}
+
+	var (
+		secondLevelPkts    []*tappsbt.VPacket
+		secondLevelSigDesc lfn.Option[cmsg.TapscriptSigDesc]
 	)
 
-	// With the vPackets fully generated and signed above, we'll serialize
-	// it into a resolution blob to return.
-	return lfn.AndThen(
-		sPkts, func(vPkts []*tappsbt.VPacket) lfn.Result[tlv.Blob] {
-			res := cmsg.NewContractResolution(
-				vPkts, nil, lfn.None[cmsg.TapscriptSigDesc](),
-			)
+	// We'll only need a set of second level packets if we're sweeping a set
+	// of HTLC outputs on the local party's commitment transaction.
+	if needsSecondLevel {
+		log.Infof("Creating+signing 2nd level vPkts")
+
+		// We'll make a place holder for the second level output based
+		// on the assetID+value tuple.
+		secondLevelInputs := []*cmsg.AssetOutput{cmsg.NewAssetOutput(
+			assetOutputs[0].AssetID.Val,
+			assetOutputs[0].Amount.Val, assetOutputs[0].Proof.Val,
+		)}
+
+		// Unlike the first level packets, we can't yet sign the second
+		// level packets yet, as we don't know what the sweeping
+		// transaction will look like. So we'll just create them.
+		secondLevelPkts, err = lfn.MapOption(
+			func(desc tapscriptSweepDesc) lfn.Result[[]*tappsbt.VPacket] {
+				return a.createSweepVpackets(
+					secondLevelInputs, lfn.Ok(desc), req,
+				)
+			},
+		)(tapSweepDesc.secondLevel).UnwrapOr(
+			lfn.Ok[[]*tappsbt.VPacket](nil),
+		).Unpack()
+		if err != nil {
+			return lfn.Errf[tlv.Blob]("unable to make "+
+				"second level pkts: %w", err)
+		}
+
+		// We'll update some of the details of the 2nd level pkt based
+		// on the first lvl packet created above (as we don't yet have
+		// the full proof for the first lvl packet above).
+		for pktIdx, vPkt := range secondLevelPkts {
+			prevAsset := firstLevelPkts[pktIdx].Outputs[0].Asset
 
-			var b bytes.Buffer
-			if err := res.Encode(&b); err != nil {
-				return lfn.Err[returnType](err)
+			for inputIdx, vIn := range vPkt.Inputs {
+				//nolint:lll
+				prevScriptKey := prevAsset.ScriptKey
+				vIn.PrevID.ScriptKey = asset.ToSerialized(
+					prevScriptKey.PubKey,
+				)
+
+				vPkt.SetInputAsset(inputIdx, prevAsset)
 			}
+		}
 
-			return lfn.Ok(b.Bytes())
-		},
+		// With the vPackets fully generated and signed above, we'll
+		// serialize it into a resolution blob to return.
+		secondLevelSigDesc = lfn.MapOption(
+			func(d tapscriptSweepDesc) cmsg.TapscriptSigDesc {
+				return cmsg.NewTapscriptSigDesc(
+					d.scriptTree.TapTweak(),
+					d.ctrlBlockBytes,
+				)
+			},
+		)(tapSweepDesc.secondLevel)
+	}
+
+	res := cmsg.NewContractResolution(
+		firstLevelPkts, secondLevelPkts, secondLevelSigDesc,
 	)
+
+	var b bytes.Buffer
+	if err := res.Encode(&b); err != nil {
+		return lfn.Err[tlv.Blob](err)
+	}
+
+	return lfn.Ok(b.Bytes())
 }
 
 // preimageDesc is a helper struct that contains the preimage and the witness