[wallet 3/3]: group key support for channel funding

.github/workflows/main.yaml

@@ -21,7 +21,7 @@ env:
 
   GO_VERSION: '1.23.6'
 
-  LITD_ITEST_BRANCH: 'closedchannel-data'
+  LITD_ITEST_BRANCH: 'group-key-support'
 
 jobs:
   #######################

rpcserver.go

@@ -3561,6 +3561,16 @@ func marshalOutboundParcel(
 			return nil, err
 		}
 
+		var proofAsset asset.Asset
+		err = proof.SparseDecode(
+			bytes.NewReader(out.ProofSuffix),
+			proof.AssetLeafRecord(&proofAsset),
+		)
+		if err != nil {
+			return nil, fmt.Errorf("unable to sparse decode "+
+				"proof: %w", err)
+		}
+
 		// Marshall the proof delivery status.
 		proofDeliveryStatus := marshalOutputProofDeliveryStatus(out)
 
@@ -3576,6 +3586,7 @@ func marshalOutboundParcel(
 			OutputType:          rpcOutType,
 			AssetVersion:        assetVersion,
 			ProofDeliveryStatus: proofDeliveryStatus,
+			AssetId:             fn.ByteSlice(proofAsset.ID()),
 		}
 	}
 
@@ -7099,7 +7110,7 @@ func (r *rpcServer) FundChannel(ctx context.Context,
 	}
 
 	assetID, groupKey, err := parseAssetSpecifier(
-		req.GetAssetId(), "", nil, "",
+		req.GetAssetId(), "", req.GetGroupKey(), "",
 	)
 	if err != nil {
 		return nil, fmt.Errorf("error parsing asset specifier: %w", err)

tapchannel/aux_closer.go

@@ -104,7 +104,7 @@ func NewAuxChanCloser(cfg AuxChanCloserCfg) *AuxChanCloser {
 // createCloseAlloc is a helper function that creates an allocation for an asset
 // close. This does not set a script key, as the script key will be set for each
 // packet after the coins have been distributed.
-func createCloseAlloc(isLocal, isInitiator bool, outputSum uint64,
+func createCloseAlloc(isLocal bool, outputSum uint64,
 	shutdownMsg tapchannelmsg.AuxShutdownMsg) (*tapsend.Allocation, error) {
 
 	// The sort pkScript for the allocation will just be the internal key,
@@ -146,7 +146,6 @@ func createCloseAlloc(isLocal, isInitiator bool, outputSum uint64,
 
 			return tapsend.CommitAllocationToRemote
 		}(),
-		SplitRoot:            isInitiator,
 		InternalKey:          shutdownMsg.AssetInternalKey.Val,
 		GenScriptKey:         scriptKeyGen,
 		Amount:               outputSum,
@@ -157,24 +156,58 @@ func createCloseAlloc(isLocal, isInitiator bool, outputSum uint64,
 	}, nil
 }
 
-// fundingSpendWitness creates a complete witness to spend the OP_TRUE funding
-// script of an asset funding output.
-func fundingSpendWitness() lfn.Result[wire.TxWitness] {
-	fundingScriptTree := tapscript.NewChannelFundingScriptTree()
+// signCommitVirtualPackets signs the commit virtual packets with the funding
+// witness, which is just the script and control block for the OP_TRUE spend.
+func signCommitVirtualPackets(ctx context.Context,
+	vPackets []*tappsbt.VPacket) error {
 
-	tapscriptTree := fundingScriptTree.TapscriptTree
-	ctrlBlock := tapscriptTree.LeafMerkleProofs[0].ToControlBlock(
-		&input.TaprootNUMSKey,
-	)
-	ctrlBlockBytes, err := ctrlBlock.ToBytes()
-	if err != nil {
-		return lfn.Errf[wire.TxWitness]("unable to serialize control "+
-			"block: %w", err)
+	useUniqueScriptKey := len(vPackets) > 1
+	for idx := range vPackets {
+		assetID, err := vPackets[idx].AssetID()
+		if err != nil {
+			return fmt.Errorf("unable to get asset ID: %w", err)
+		}
+
+		// First, we'll prepare the funding witness which includes the
+		// OP_TRUE ctrl block.
+		fundingWitness, err := tapscript.ChannelFundingSpendWitness(
+			useUniqueScriptKey, assetID,
+		)
+		if err != nil {
+			return fmt.Errorf("unable to make funding witness: %w",
+				err)
+		}
+
+		err = tapsend.PrepareOutputAssets(ctx, vPackets[idx])
+		if err != nil {
+			return fmt.Errorf("unable to prepare output "+
+				"assets: %w", err)
+		}
+
+		// With the packets prepared, we'll swap in the correct witness
+		// for each of them. We need to do this _after_ calling
+		// PrepareOutputAsset, because that method will overwrite any
+		// asset in the virtual outputs. Which means we'll also need to
+		// set the witness on _every_ output of the packet, to make sure
+		// each split output's root asset reference also gets the
+		// correct witness.
+		for outIdx := range vPackets[idx].Outputs {
+			outAsset := vPackets[idx].Outputs[outIdx].Asset
+
+			// There is always only a single input, as we're
+			// spending a single funding output w/ each vPkt.
+			const inputIndex = 0
+			err := outAsset.UpdateTxWitness(
+				inputIndex, fundingWitness,
+			)
+			if err != nil {
+				return fmt.Errorf("error updating witness: %w",
+					err)
+			}
+		}
 	}
 
-	return lfn.Ok(wire.TxWitness{
-		tapscript.AnyoneCanSpendScript(), ctrlBlockBytes,
-	})
+	return nil
 }
 
 // AuxCloseOutputs returns the set of close outputs to use for this co-op close
@@ -273,7 +306,7 @@ func (a *AuxChanCloser) AuxCloseOutputs(
 	remoteSum := fn.Reduce(commitState.RemoteAssets.Val.Outputs, sumAmounts)
 	if localSum > 0 {
 		localAlloc, err = createCloseAlloc(
-			true, desc.Initiator, localSum, localShutdown,
+			true, localSum, localShutdown,
 		)
 		if err != nil {
 			return none, err
@@ -285,7 +318,7 @@ func (a *AuxChanCloser) AuxCloseOutputs(
 	}
 	if remoteSum > 0 {
 		remoteAlloc, err = createCloseAlloc(
-			false, !desc.Initiator, remoteSum, remoteShutdown,
+			false, remoteSum, remoteShutdown,
 		)
 		if err != nil {
 			return none, err
@@ -378,35 +411,12 @@ func (a *AuxChanCloser) AuxCloseOutputs(
 		return none, fmt.Errorf("unable to distribute coins: %w", err)
 	}
 
-	// With the vPackets created we'll now prepare all the split
-	// information encoded in the vPackets.
-	fundingWitness, err := fundingSpendWitness().Unpack()
-	if err != nil {
-		return none, fmt.Errorf("unable to make funding "+
-			"witness: %w", err)
-	}
-	ctx := context.Background()
-	for idx := range vPackets {
-		err := tapsend.PrepareOutputAssets(ctx, vPackets[idx])
-		if err != nil {
-			return none, fmt.Errorf("unable to prepare output "+
-				"assets: %w", err)
-		}
-
-		for outIdx := range vPackets[idx].Outputs {
-			outAsset := vPackets[idx].Outputs[outIdx].Asset
-
-			// There is always only a single input, which is the
-			// funding output.
-			const inputIndex = 0
-			err := outAsset.UpdateTxWitness(
-				inputIndex, fundingWitness,
-			)
-			if err != nil {
-				return none, fmt.Errorf("error updating "+
-					"witness: %w", err)
-			}
-		}
+	// We can now add the witness for the OP_TRUE spend of the commitment
+	// output to the vPackets.
+	ctxb := context.Background()
+	if err := signCommitVirtualPackets(ctxb, vPackets); err != nil {
+		return none, fmt.Errorf("error signing commit virtual "+
+			"packets: %w", err)
 	}
 
 	// With the outputs prepared, we can now create the set of output
@@ -484,8 +494,9 @@ func (a *AuxChanCloser) ShutdownBlob(
 	none := lfn.None[lnwire.CustomRecords]()
 
 	// If there's no custom blob, then we don't need to do anything.
-	if req.CommitBlob.IsNone() {
-		log.Debugf("No commit blob for ChannelPoint(%v)", req.ChanPoint)
+	if req.FundingBlob.IsNone() {
+		log.Debugf("No funding blob for ChannelPoint(%v)",
+			req.ChanPoint)
 		return none, nil
 	}
 
@@ -500,16 +511,16 @@ func (a *AuxChanCloser) ShutdownBlob(
 	log.Infof("Creating shutdown blob for close of ChannelPoint(%v)",
 		req.ChanPoint)
 
-	// Otherwise, we'll decode the commitment, so we can examine the current
-	// state.
-	var commitState tapchannelmsg.Commitment
-	err = lfn.MapOptionZ(req.CommitBlob, func(blob tlv.Blob) error {
-		c, err := tapchannelmsg.DecodeCommitment(blob)
+	// Otherwise, we'll decode the funding state, so we can examine the
+	// different asset IDs in the channel.
+	var fundingState tapchannelmsg.OpenChannel
+	err = lfn.MapOptionZ(req.FundingBlob, func(blob tlv.Blob) error {
+		c, err := tapchannelmsg.DecodeOpenChannel(blob)
 		if err != nil {
 			return err
 		}
 
-		commitState = *c
+		fundingState = *c
 
 		return nil
 	})
@@ -528,38 +539,34 @@ func (a *AuxChanCloser) ShutdownBlob(
 		return none, err
 	}
 
-	// Next, we'll collect all the assets that we own in this channel.
-	assets := commitState.LocalAssets.Val.Outputs
+	// Next, we'll collect all the asset IDs that were committed to the
+	// channel.
+	assetIDs := fn.Map(
+		fundingState.FundedAssets.Val.Outputs,
+		func(o *tapchannelmsg.AssetOutput) asset.ID {
+			return o.AssetID.Val
+		},
+	)
 
 	// Now that we have all the asset IDs, we'll query for a new key for
 	// each of them which we'll use as both the internal key and the script
 	// key.
 	scriptKeys := make(tapchannelmsg.ScriptKeyMap)
-	for idx := range assets {
-		channelAsset := assets[idx]
-
+	for _, assetID := range assetIDs {
 		newKey, err := a.cfg.AddrBook.NextScriptKey(
 			ctx, asset.TaprootAssetsKeyFamily,
 		)
 		if err != nil {
 			return none, err
 		}
 
-		// We now add the a
-		// TODO(guggero): This only works if there's only a single asset
-		// in the channel. We need to extend this to support multiple
-		// assets.
-		_, err = a.cfg.AddrBook.NewAddressWithKeys(
-			ctx, address.V1, channelAsset.AssetID.Val,
-			channelAsset.Amount.Val, newKey, newInternalKey, nil,
-			*a.cfg.DefaultCourierAddr,
-		)
+		err = a.cfg.AddrBook.InsertScriptKey(ctx, newKey, true)
 		if err != nil {
-			return none, fmt.Errorf("error adding new address: %w",
-				err)
+			return none, fmt.Errorf("error declaring script key: "+
+				"%w", err)
 		}
 
-		scriptKeys[channelAsset.AssetID.Val] = *newKey.PubKey
+		scriptKeys[assetID] = *newKey.PubKey
 	}
 
 	// Finally, we'll map the extra shutdown info to a TLV record map we