tapfreighter: extract functions

Author: guggero

tapfreighter/fund.go

@@ -67,6 +67,56 @@ func createFundedPacketWithInputs(ctx context.Context, exporter proof.Exporter,
 		return nil, err
 	}
 
+	// Make sure we'll recognize local script keys in the virtual packet
+	// later on in the process by annotating them with the full descriptor
+	// information.
+	if err := annotateLocalScriptKeys(ctx, vPkt, addrBook); err != nil {
+		return nil, err
+	}
+
+	// If we don't spend the full value, we need to create a change output.
+	changeAmount := totalInputAmt - fundDesc.Amount
+	err = createChangeOutput(ctx, vPkt, keyRing, fullValue, changeAmount)
+	if err != nil {
+		return nil, err
+	}
+
+	// Before we can prepare output assets for our send, we need to generate
+	// a new internal key for the anchor outputs. We assume any output that
+	// hasn't got an internal key set is going to a local anchor, and we
+	// provide the internal key for that.
+	for idx := range vPkt.Outputs {
+		vOut := vPkt.Outputs[idx]
+		if vOut.AnchorOutputInternalKey != nil {
+			continue
+		}
+
+		newInternalKey, err := keyRing.DeriveNextKey(
+			ctx, asset.TaprootAssetsKeyFamily,
+		)
+		if err != nil {
+			return nil, err
+		}
+		vOut.SetAnchorInternalKey(
+			newInternalKey, vPkt.ChainParams.HDCoinType,
+		)
+	}
+
+	if err := tapsend.PrepareOutputAssets(ctx, vPkt); err != nil {
+		return nil, fmt.Errorf("unable to prepare outputs: %w", err)
+	}
+
+	return &FundedVPacket{
+		VPackets:         []*tappsbt.VPacket{vPkt},
+		InputCommitments: inputCommitments,
+	}, nil
+}
+
+// annotateLocalScriptKeys annotates the local script keys in the given virtual
+// packet with the full descriptor information.
+func annotateLocalScriptKeys(ctx context.Context, vPkt *tappsbt.VPacket,
+	addrBook AddrBook) error {
+
 	// We want to know if we are sending to ourselves. We detect that by
 	// looking at the key descriptor of the script key. Because that is not
 	// part of addresses and might not be specified by the user through the
@@ -90,14 +140,24 @@ func createFundedPacketWithInputs(ctx context.Context, exporter proof.Exporter,
 			continue
 
 		default:
-			return nil, fmt.Errorf("cannot fetch script key: %w",
-				err)
+			return fmt.Errorf("cannot fetch script key: %w", err)
 		}
 	}
 
+	return nil
+}
+
+// createChangeOutput creates a change output for the given virtual packet if
+// it isn't fully spent.
+func createChangeOutput(ctx context.Context, vPkt *tappsbt.VPacket,
+	keyRing KeyRing, fullValue bool, changeAmount uint64) error {
+
 	// We expect some change back, or have passive assets to commit to, so
 	// let's make sure we create a transfer output.
-	var changeOut *tappsbt.VOutput
+	var (
+		changeOut *tappsbt.VOutput
+		err       error
+	)
 	if !fullValue {
 		// Do we need to add a change output?
 		changeOut, err = vPkt.SplitRootOutput()
@@ -127,15 +187,15 @@ func createFundedPacketWithInputs(ctx context.Context, exporter proof.Exporter,
 		// to attach the passive assets to.
 		unSpendable, err := changeOut.ScriptKey.IsUnSpendable()
 		if err != nil {
-			return nil, fmt.Errorf("cannot determine if script "+
-				"key is spendable: %w", err)
+			return fmt.Errorf("cannot determine if script key is "+
+				"spendable: %w", err)
 		}
-		if unSpendable && !fullValue {
+		if unSpendable {
 			changeScriptKey, err := keyRing.DeriveNextKey(
 				ctx, asset.TaprootAssetsKeyFamily,
 			)
 			if err != nil {
-				return nil, err
+				return err
 			}
 
 			// We'll assume BIP-0086 everywhere, and use the tweaked
@@ -148,7 +208,7 @@ func createFundedPacketWithInputs(ctx context.Context, exporter proof.Exporter,
 		// For existing change outputs, we'll just update the amount
 		// since we might not have known what coin would've been
 		// selected and how large the change would turn out to be.
-		changeOut.Amount = totalInputAmt - fundDesc.Amount
+		changeOut.Amount = changeAmount
 
 		// The asset version of the output should be the max of the set
 		// of input versions. We need to set this now as in
@@ -170,35 +230,7 @@ func createFundedPacketWithInputs(ctx context.Context, exporter proof.Exporter,
 		changeOut.AssetVersion = fn.Reduce(vPkt.Inputs, maxVersion)
 	}
 
-	// Before we can prepare output assets for our send, we need to generate
-	// a new internal key for the anchor outputs. We assume any output that
-	// hasn't got an internal key set is going to a local anchor, and we
-	// provide the internal key for that.
-	for idx := range vPkt.Outputs {
-		vOut := vPkt.Outputs[idx]
-		if vOut.AnchorOutputInternalKey != nil {
-			continue
-		}
-
-		newInternalKey, err := keyRing.DeriveNextKey(
-			ctx, asset.TaprootAssetsKeyFamily,
-		)
-		if err != nil {
-			return nil, err
-		}
-		vOut.SetAnchorInternalKey(
-			newInternalKey, vPkt.ChainParams.HDCoinType,
-		)
-	}
-
-	if err := tapsend.PrepareOutputAssets(ctx, vPkt); err != nil {
-		return nil, fmt.Errorf("unable to prepare outputs: %w", err)
-	}
-
-	return &FundedVPacket{
-		VPackets:         []*tappsbt.VPacket{vPkt},
-		InputCommitments: inputCommitments,
-	}, nil
+	return nil
 }
 
 // setVPacketInputs sets the inputs of the given vPkt to the given send eligible