tapchannel: refactor result type

This commit unifies the use of the lfn.Result return type as a
preparation for the final commit in this PR, where we change a bunch of
function/method signatures to use the Result type as well.

We use lnf.Err(fnt.Errorf()) instead of lnf.Errf because the
intellisense of some IDEs complain about the '%w' verb only being usable
with fmt.Errorf().

Author: guggero

tapchannel/aux_closer.go

@@ -152,7 +152,7 @@ func createCloseAlloc(isLocal, isInitiator bool, closeAsset *asset.Asset,
 	}, nil
 }
 
-// fundingSpendwitness creates a complete witness to spend the OP_TRUE funding
+// 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()

tapchannel/aux_sweeper.go

@@ -178,13 +178,15 @@ func (a *AuxSweeper) createSweepVpackets(sweepInputs []*cmsg.AssetOutput,
 	tapscriptDesc lfn.Result[tapscriptSweepDesc],
 ) lfn.Result[[]*tappsbt.VPacket] {
 
+	type returnType = []*tappsbt.VPacket
+
 	log.Infof("Creating sweep packets for %v inputs", len(sweepInputs))
 
 	// Unpack the tapscript desc, as we need it to be able to continue
 	// forward.
 	sweepDesc, err := tapscriptDesc.Unpack()
 	if err != nil {
-		return lfn.Err[[]*tappsbt.VPacket](err)
+		return lfn.Err[returnType](err)
 	}
 
 	// For each out we want to sweep, we'll construct an allocation that
@@ -198,7 +200,7 @@ func (a *AuxSweeper) createSweepVpackets(sweepInputs []*cmsg.AssetOutput,
 			ctx, asset.TaprootAssetsKeyFamily,
 		)
 		if err != nil {
-			return lfn.Err[[]*tappsbt.VPacket](err)
+			return lfn.Err[returnType](err)
 		}
 
 		// With the script key created, we can make a new allocation
@@ -239,17 +241,16 @@ func (a *AuxSweeper) createSweepVpackets(sweepInputs []*cmsg.AssetOutput,
 		inputProofs, allocs, &a.cfg.ChainParams,
 	)
 	if err != nil {
-		return lfn.Errf[[]*tappsbt.VPacket]("error distributing "+
-			"coins: %w", err)
+		return lfn.Errf[returnType]("error distributing coins: %w", err)
 	}
 
 	log.Infof("Created %v sweep packets: %v", len(vPackets),
 		limitSpewer.Sdump(vPackets))
 
 	fundingWitness, err := fundingSpendWitness().Unpack()
 	if err != nil {
-		return lfn.Errf[[]*tappsbt.VPacket]("unable to make "+
-			"funding witness: %v", err)
+		return lfn.Errf[returnType]("unable to make funding witness: "+
+			"%w", err)
 	}
 
 	// Next, we'll prepare all the vPackets for the sweep transaction, and
@@ -266,8 +267,8 @@ func (a *AuxSweeper) createSweepVpackets(sweepInputs []*cmsg.AssetOutput,
 
 		err := tapsend.PrepareOutputAssets(ctx, vPackets[idx])
 		if err != nil {
-			return lfn.Errf[[]*tappsbt.VPacket]("unable to "+
-				"prepare output assets: %w", err)
+			return lfn.Errf[returnType]("unable to prepare output "+
+				"assets: %w", err)
 		}
 
 		// Next before we sign, we'll make sure to update the witness
@@ -355,6 +356,8 @@ func (a *AuxSweeper) createAndSignSweepVpackets(
 	sweepDesc lfn.Result[tapscriptSweepDesc],
 ) lfn.Result[[]*tappsbt.VPacket] {
 
+	type returnType = []*tappsbt.VPacket
+
 	// Based on the sweep inputs, make vPackets that sweep all the inputs
 	// into a new output with a fresh script key. They won't have an
 	// internal key set, we'll do that when we go to make the output to
@@ -365,7 +368,7 @@ func (a *AuxSweeper) createAndSignSweepVpackets(
 
 		err := a.signSweepVpackets(vPkts, signDesc, desc)
 		if err != nil {
-			return lfn.Err[[]*tappsbt.VPacket](err)
+			return lfn.Err[returnType](err)
 		}
 
 		return lfn.Ok(vPkts)
@@ -398,15 +401,17 @@ type tapscriptSweepDesc struct {
 func commitNoDelaySweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 	csvDelay uint32) lfn.Result[tapscriptSweepDesc] {
 
+	type returnType = tapscriptSweepDesc
+
 	// We'll make the script tree for the to remote script (we're remote as
 	// this is their commitment transaction). We don't have an auxLeaf here
 	// as we're on the TAP layer.
 	toRemoteScriptTree, err := input.NewRemoteCommitScriptTree(
 		keyRing.ToRemoteKey, input.NoneTapLeaf(),
 	)
 	if err != nil {
-		return lfn.Errf[tapscriptSweepDesc]("unable to make remote "+
-			"script tree: %w", err)
+		return lfn.Errf[returnType]("unable to make remote script "+
+			"tree: %w", err)
 	}
 
 	// Now that we have the script tree, we'll make the control block
@@ -415,13 +420,13 @@ func commitNoDelaySweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 		input.ScriptPathSuccess,
 	)
 	if err != nil {
-		return lfn.Errf[tapscriptSweepDesc]("unable to make "+
-			"ctrl block: %w", err)
+		return lfn.Errf[returnType]("unable to make ctrl block: %w",
+			err)
 	}
 	ctrlBlockBytes, err := ctrlBlock.ToBytes()
 	if err != nil {
-		return lfn.Errf[tapscriptSweepDesc]("unable to encode ctrl "+
-			"block: %w", err)
+		return lfn.Errf[returnType]("unable to encode ctrl block: %w",
+			err)
 	}
 
 	return lfn.Ok(tapscriptSweepDesc{
@@ -437,6 +442,8 @@ func commitNoDelaySweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 func commitDelaySweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 	csvDelay uint32) lfn.Result[tapscriptSweepDesc] {
 
+	type returnType = tapscriptSweepDesc
+
 	// We'll make the script tree for the to remote script (we're remote as
 	// this is their commitment transaction). We don't have an auxLeaf here
 	// as we're on the TAP layer.
@@ -445,7 +452,7 @@ func commitDelaySweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 		input.NoneTapLeaf(),
 	)
 	if err != nil {
-		return lfn.Err[tapscriptSweepDesc](err)
+		return lfn.Err[returnType](err)
 	}
 
 	// Now that we have the script tree, we'll make the control block
@@ -454,11 +461,11 @@ func commitDelaySweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 		input.ScriptPathSuccess,
 	)
 	if err != nil {
-		return lfn.Err[tapscriptSweepDesc](err)
+		return lfn.Err[returnType](err)
 	}
 	ctrlBlockBytes, err := ctrlBlock.ToBytes()
 	if err != nil {
-		return lfn.Err[tapscriptSweepDesc](err)
+		return lfn.Err[returnType](err)
 	}
 
 	return lfn.Ok(tapscriptSweepDesc{
@@ -474,6 +481,8 @@ func commitDelaySweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 func commitRevokeSweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 	csvDelay uint32) lfn.Result[tapscriptSweepDesc] {
 
+	type returnType = tapscriptSweepDesc
+
 	// To sweep their revoked output, we'll make the script tree for the
 	// local tree of their commitment transaction, which is actually their
 	// output.
@@ -482,7 +491,7 @@ func commitRevokeSweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 		input.NoneTapLeaf(),
 	)
 	if err != nil {
-		return lfn.Err[tapscriptSweepDesc](err)
+		return lfn.Err[returnType](err)
 	}
 
 	// Now that we have the script tree, we'll make the control block
@@ -491,11 +500,11 @@ func commitRevokeSweepDesc(keyRing *lnwallet.CommitmentKeyRing,
 		input.ScriptPathRevocation,
 	)
 	if err != nil {
-		return lfn.Err[tapscriptSweepDesc](err)
+		return lfn.Err[returnType](err)
 	}
 	ctrlBlockBytes, err := ctrlBlock.ToBytes()
 	if err != nil {
-		return lfn.Err[tapscriptSweepDesc](err)
+		return lfn.Err[returnType](err)
 	}
 
 	return lfn.Ok(tapscriptSweepDesc{
@@ -1098,6 +1107,8 @@ func (a *AuxSweeper) importCommitTx(req lnwallet.ResolutionReq,
 func (a *AuxSweeper) resolveContract(
 	req lnwallet.ResolutionReq) lfn.Result[tlv.Blob] {
 
+	type returnType = tlv.Blob
+
 	// If there's no commit blob, then there's nothing to resolve.
 	if req.CommitBlob.IsNone() {
 		return lfn.Err[tlv.Blob](nil)
@@ -1113,13 +1124,13 @@ func (a *AuxSweeper) resolveContract(
 		req.CommitBlob.UnwrapOr(nil),
 	)
 	if err != nil {
-		return lfn.Err[tlv.Blob](err)
+		return lfn.Err[returnType](err)
 	}
 	fundingInfo, err := tapchannelmsg.DecodeOpenChannel(
 		req.FundingBlob.UnwrapOr(nil),
 	)
 	if err != nil {
-		return lfn.Err[tlv.Blob](err)
+		return lfn.Err[returnType](err)
 	}
 
 	// To be able to construct all the proofs we need to spend later, we'll
@@ -1131,16 +1142,16 @@ func (a *AuxSweeper) resolveContract(
 		ctx, fn.Some(req.CommitTx.TxHash()), false,
 	)
 	if err != nil {
-		return lfn.Err[tlv.Blob](err)
+		return lfn.Err[returnType](err)
 	}
 	if len(commitParcel) == 0 {
 		log.Infof("First time seeing commit_txid=%v, importing",
 			req.CommitTx.TxHash())
 
 		err := a.importCommitTx(req, commitState, fundingInfo)
 		if err != nil {
-			return lfn.Errf[tlv.Blob]("unable to import "+
-				"commitment txn: %v", err)
+			return lfn.Errf[returnType]("unable to import "+
+				"commitment txn: %w", err)
 		}
 	} else {
 		log.Infof("Commitment commit_txid=%v already imported, "+
@@ -1191,8 +1202,8 @@ func (a *AuxSweeper) resolveContract(
 		sweepDesc = commitRevokeSweepDesc(req.KeyRing, req.CsvDelay)
 
 	default:
-		return lfn.Err[tlv.Blob](fmt.Errorf("unknown resolution "+
-			"type: %v", req.Type))
+		return lfn.Errf[returnType]("unknown resolution type: %v",
+			req.Type)
 	}
 
 	// The input proofs above were made originally using the fake commit tx
@@ -1219,7 +1230,7 @@ func (a *AuxSweeper) resolveContract(
 
 			var b bytes.Buffer
 			if err := res.Encode(&b); err != nil {
-				return lfn.Err[tlv.Blob](err)
+				return lfn.Err[returnType](err)
 			}
 
 			return lfn.Ok(b.Bytes())
@@ -1231,6 +1242,8 @@ func (a *AuxSweeper) resolveContract(
 // none of the inputs have any resolution blobs. Then an empty slice will be
 // returned.
 func extractInputVPackets(inputs []input.Input) lfn.Result[[]*tappsbt.VPacket] {
+	type returnType = []*tappsbt.VPacket
+
 	// Otherwise, we'll extract the set of resolution blobs from the inputs
 	// passed in.
 	relevantInputs := fn.Filter(inputs, func(i input.Input) bool {
@@ -1255,7 +1268,7 @@ func extractInputVPackets(inputs []input.Input) lfn.Result[[]*tappsbt.VPacket] {
 		},
 	)
 	if err != nil {
-		return lfn.Err[[]*tappsbt.VPacket](err)
+		return lfn.Err[returnType](err)
 	}
 
 	return lfn.Ok(vPkts)
@@ -1267,13 +1280,15 @@ func extractInputVPackets(inputs []input.Input) lfn.Result[[]*tappsbt.VPacket] {
 func (a *AuxSweeper) sweepContracts(inputs []input.Input,
 	change lnwallet.AddrWithKey) lfn.Result[sweep.SweepOutput] {
 
+	type returnType = sweep.SweepOutput
+
 	// If none of the inputs have a resolution blob, then we have nothing
 	// to generate.
 	if fn.NotAny(inputs, func(i input.Input) bool {
 		return !i.ResolutionBlob().IsNone()
 	}) {
 
-		return lfn.Err[sweep.SweepOutput](nil)
+		return lfn.Err[returnType](nil)
 	}
 
 	// TODO(roasbeef): can pipline entire thing instead?
@@ -1282,7 +1297,7 @@ func (a *AuxSweeper) sweepContracts(inputs []input.Input,
 	// vPackets from the inputs.
 	vPkts, err := extractInputVPackets(inputs).Unpack()
 	if err != nil {
-		return lfn.Err[sweep.SweepOutput](err)
+		return lfn.Err[returnType](err)
 	}
 
 	log.Infof("Generating anchor output for vpkts=%v",
@@ -1297,7 +1312,7 @@ func (a *AuxSweeper) sweepContracts(inputs []input.Input,
 		context.Background(), asset.TaprootAssetsKeyFamily,
 	)
 	if err != nil {
-		return lfn.Err[sweep.SweepOutput](err)
+		return lfn.Err[returnType](err)
 	}
 	for idx := range vPkts {
 		for _, vOut := range vPkts[idx].Outputs {
@@ -1311,15 +1326,14 @@ func (a *AuxSweeper) sweepContracts(inputs []input.Input,
 	// out of all the vPackets contained.
 	outCommitments, err := tapsend.CreateOutputCommitments(vPkts)
 	if err != nil {
-		return lfn.Errf[sweep.SweepOutput]("unable to create output "+
-			"commitments: %w", err)
+		return lfn.Errf[returnType]("unable to create "+
+			"output commitments: %w", err)
 	}
 
 	// We should only have a single output commitment at this point.
 	if len(outCommitments) != 1 {
-		return lfn.Err[sweep.SweepOutput](fmt.Errorf("expected a "+
-			"single output commitment, got: %v",
-			len(outCommitments)))
+		return lfn.Errf[returnType]("expected a single output "+
+			"commitment, got: %v", len(outCommitments))
 	}
 
 	// With the output commitments created, we'll now create the anchor
@@ -1328,7 +1342,7 @@ func (a *AuxSweeper) sweepContracts(inputs []input.Input,
 		internalKey.PubKey, nil, outCommitments[0],
 	)
 	if err != nil {
-		return lfn.Err[sweep.SweepOutput](err)
+		return lfn.Err[returnType](err)
 	}
 
 	return lfn.Ok(sweep.SweepOutput{
@@ -1351,8 +1365,8 @@ func sweepExclusionProofGen(sweepInternalKey keychain.KeyDescriptor,
 
 		tsProof, err := proof.CreateTapscriptProof(nil)
 		if err != nil {
-			return fmt.Errorf("error creating tapscript "+
-				"proof: %w", err)
+			return fmt.Errorf("error creating tapscript proof: %w",
+				err)
 		}
 
 		// We only need to generate an exclusion proof for the second
@@ -1507,18 +1521,20 @@ func (a *AuxSweeper) contractResolver() {
 func (a *AuxSweeper) ResolveContract(
 	req lnwallet.ResolutionReq) lfn.Result[tlv.Blob] {
 
+	type returnType = tlv.Blob
+
 	auxReq := &resolutionReq{
 		req:  req,
 		resp: make(chan lfn.Result[tlv.Blob], 1),
 	}
 
 	if !fn.SendOrQuit(a.resolutionReqs, auxReq, a.quit) {
-		return lfn.Err[tlv.Blob](fmt.Errorf("aux sweeper stopped"))
+		return lfn.Errf[returnType]("aux sweeper stopped")
 	}
 
 	resp, quitErr := fn.RecvResp(auxReq.resp, nil, a.quit)
 	if quitErr != nil {
-		return lfn.Err[tlv.Blob](quitErr)
+		return lfn.Err[returnType](quitErr)
 	}
 
 	return resp
@@ -1530,21 +1546,21 @@ func (a *AuxSweeper) ResolveContract(
 func (a *AuxSweeper) DeriveSweepAddr(inputs []input.Input,
 	change lnwallet.AddrWithKey) lfn.Result[sweep.SweepOutput] {
 
+	type returnType = sweep.SweepOutput
+
 	auxReq := &sweepAddrReq{
 		inputs: inputs,
 		change: change,
 		resp:   make(chan lfn.Result[sweep.SweepOutput], 1),
 	}
 
 	if !fn.SendOrQuit(a.sweepAddrReqs, auxReq, a.quit) {
-		return lfn.Err[sweep.SweepOutput](
-			fmt.Errorf("aux sweeper stopped"),
-		)
+		return lfn.Err[returnType](fmt.Errorf("aux sweeper stopped"))
 	}
 
 	resp, quitErr := fn.RecvResp(auxReq.resp, nil, a.quit)
 	if quitErr != nil {
-		return lfn.Err[sweep.SweepOutput](quitErr)
+		return lfn.Err[returnType](quitErr)
 	}
 
 	return resp