tappsbt+tapsend: add address to vOutput

For V2 addresses we need to know certain information from the address
when creating the final send fragment. Because we might be transporting
a vPSBT over RPC boundaries between funding and finalizing, we need to
also transport the address between those steps. The easiest way to do
that is to encode the address into the virtual output directly.

Author: guggero

tappsbt/create.go

@@ -80,6 +80,7 @@ func FromAddresses(receiverAddrs []*address.Tap,
 			AnchorOutputInternalKey:      &addr.InternalKey,
 			AnchorOutputTapscriptSibling: addr.TapscriptSibling,
 			ProofDeliveryAddress:         &addr.ProofCourierAddr,
+			Address:                      addr,
 		})
 	}
 

tappsbt/decode.go

@@ -116,6 +116,7 @@ func NewFromPsbt(packet *psbt.Packet) (*VPacket, error) {
 		vOut := &VOutput{}
 		err = vOut.decode(
 			packet.Outputs[idx], packet.UnsignedTx.TxOut[idx],
+			chainParams,
 		)
 		if err != nil {
 			return nil, fmt.Errorf("error decoding virtual output "+
@@ -212,7 +213,9 @@ func (i *VInput) decode(pIn psbt.PInput) error {
 }
 
 // decode decodes the given POutput and wire.TxOut into the current VOutput.
-func (o *VOutput) decode(pOut psbt.POutput, txOut *wire.TxOut) error {
+func (o *VOutput) decode(pOut psbt.POutput, txOut *wire.TxOut,
+	chainParams *address.ChainParams) error {
+
 	o.Amount = uint64(txOut.Value)
 
 	if len(txOut.PkScript) != schnorr.PubKeyBytesLen+2 {
@@ -305,6 +308,9 @@ func (o *VOutput) decode(pOut psbt.POutput, txOut *wire.TxOut) error {
 		}, {
 			key:     PsbtKeyTypeOutputTapAltLeaves,
 			decoder: altLeavesDecoder(&o.AltLeaves),
+		}, {
+			key:     PsbtKeyTypeOutputTapAddress,
+			decoder: addressDecoder(&o.Address, chainParams),
 		}}
 
 	for idx := range mapping {
@@ -524,3 +530,28 @@ func urlDecoder(u **url.URL) decoderFunc {
 		return tlvDecoder(*u, asset.UrlDecoder)(key, byteVal)
 	}
 }
+
+// addressDecoder returns a decoder function that can handle nil Taproot
+// addresses.
+func addressDecoder(a **address.Tap,
+	chainParams *address.ChainParams) decoderFunc {
+
+	return func(key, byteVal []byte) error {
+		if len(byteVal) == 0 {
+			return nil
+		}
+
+		addr := address.Tap{
+			ChainParams: chainParams,
+		}
+		err := addr.Decode(bytes.NewReader(byteVal))
+		if err != nil {
+			return fmt.Errorf("error decoding Taproot address: %w",
+				err)
+		}
+
+		*a = &addr
+
+		return nil
+	}
+}

tappsbt/decode_test.go

@@ -193,14 +193,20 @@ func TestEncodingDecoding(t *testing.T) {
 		assertEqualPackets(t, pkg, decoded)
 	}
 
+	proofCourierAddr := address.RandProofCourierAddr(t)
 	testCases := []testCase{{
 		name: "minimal packet",
 		pkg: func(t *testing.T) *VPacket {
-			proofCourierAddr := address.RandProofCourierAddr(t)
 			addr, _, _ := address.RandAddr(
 				t, testParams, proofCourierAddr,
 			)
 
+			// The address' genesis information isn't encoded, so it
+			// will be the empty genesis after decoding. To make
+			// sure we can directly compare before and after, we
+			// also attach an empty genesis to the address.
+			addr.AttachGenesis(asset.Genesis{})
+
 			pkg, err := FromAddresses([]*address.Tap{addr.Tap}, 1)
 			require.NoError(t, err)
 			pkg.Outputs = append(pkg.Outputs, &VOutput{

tappsbt/encode.go

@@ -12,6 +12,7 @@ import (
 	"github.com/btcsuite/btcd/btcutil/psbt"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/taproot-assets/address"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/commitment"
 	"github.com/lightninglabs/taproot-assets/fn"
@@ -301,6 +302,9 @@ func (o *VOutput) encode(coinType uint32) (psbt.POutput, *wire.TxOut, error) {
 		}, {
 			key:     PsbtKeyTypeOutputTapAltLeaves,
 			encoder: altLeavesEncoder(o.AltLeaves),
+		}, {
+			key:     PsbtKeyTypeOutputTapAddress,
+			encoder: addressEncoder(o.Address),
 		},
 	}
 
@@ -527,3 +531,26 @@ func urlEncoder(val *url.URL) encoderFunc {
 		}, nil
 	}
 }
+
+// addressEncoder returns a function that encodes the given Taproot Asset
+// address as a custom PSBT field. If the address is nil, it returns nil.
+func addressEncoder(val *address.Tap) encoderFunc {
+	return func(key []byte) ([]*customPsbtField, error) {
+		if val == nil {
+			return nil, nil
+		}
+
+		var b bytes.Buffer
+		if err := val.Encode(&b); err != nil {
+			return nil, fmt.Errorf("error encoding address: %w",
+				err)
+		}
+
+		return []*customPsbtField{
+			{
+				Key:   fn.CopySlice(key),
+				Value: b.Bytes(),
+			},
+		}, nil
+	}
+}

tappsbt/interface.go

@@ -59,6 +59,7 @@ var (
 	PsbtKeyTypeOutputTapAssetLockTime                      = []byte{0x7c}
 	PsbtKeyTypeOutputTapAssetRelativeLockTime              = []byte{0x7d}
 	PsbtKeyTypeOutputTapAltLeaves                          = []byte{0x7e}
+	PsbtKeyTypeOutputTapAddress                            = []byte{0x7f}
 )
 
 // The following keys are used as custom fields on the BTC level anchor
@@ -597,6 +598,11 @@ type VOutput struct {
 	// data-carrying leaves are used for a purpose distinct from
 	// representing individual Taproot Assets.
 	AltLeaves []asset.AltLeaf[asset.Asset]
+
+	// Address is the Taproot Asset address that was used to create this
+	// output. This is only present for non-interactive outputs that were
+	// created from a Taproot Asset address.
+	Address *address.Tap
 }
 
 // Copy creates a deep copy of the VOutput.
@@ -625,6 +631,7 @@ func (o *VOutput) Copy() *VOutput {
 		ProofDeliveryAddress:         o.ProofDeliveryAddress,
 		ProofSuffix:                  o.ProofSuffix,
 		AltLeaves:                    asset.CopyAltLeaves(o.AltLeaves),
+		Address:                      o.Address,
 	}
 }
 

tappsbt/mock.go

@@ -116,6 +116,17 @@ func RandPacket(t testing.TB, setVersion, altLeaves bool) *VPacket {
 	courierAddress, err := url.Parse("https://example.com")
 	require.NoError(t, err)
 
+	courierURL := address.RandProofCourierAddr(t)
+	addr1, _, _ := address.RandAddr(t, testParams, courierURL)
+	addr2, _, _ := address.RandAddr(t, testParams, courierURL)
+
+	// The address' genesis information isn't encoded, so it will be the
+	// empty genesis after decoding. To make sure we can directly compare
+	// before and after, we also attach an empty genesis to the two
+	// addresses.
+	addr1.AttachGenesis(asset.Genesis{})
+	addr2.AttachGenesis(asset.Genesis{})
+
 	randVInput := VInput{
 		PrevID: asset.PrevID{
 			OutPoint:  op,
@@ -154,6 +165,7 @@ func RandPacket(t testing.TB, setVersion, altLeaves bool) *VPacket {
 		ProofSuffix:                        &inputProof,
 		RelativeLockTime:                   345,
 		LockTime:                           456,
+		Address:                            addr1.Tap,
 	}
 
 	randVOutput2 := VOutput{
@@ -170,6 +182,7 @@ func RandPacket(t testing.TB, setVersion, altLeaves bool) *VPacket {
 		Asset:                              testOutputAsset,
 		ScriptKey:                          testOutputAsset.ScriptKey,
 		AnchorOutputTapscriptSibling:       &testPreimage2,
+		Address:                            addr2.Tap,
 	}
 
 	if altLeaves {
@@ -614,6 +627,11 @@ func NewTestFromVOutput(t testing.TB, v *VOutput,
 			)
 		}
 	}
+
+	if v.Address != nil {
+		vo.Address = address.NewTestFromAddress(t, v.Address)
+	}
+
 	return vo
 }
 
@@ -640,6 +658,7 @@ type TestVOutput struct {
 	RelativeLockTime              uint64                   `json:"relative_lock_time"`
 	LockTime                      uint64                   `json:"lock_time"`
 	AltLeaves                     []*asset.TestAsset       `json:"alt_leaves"`
+	Address                       *address.TestAddress     `json:"address"`
 }
 
 func (to *TestVOutput) ToVOutput(t testing.TB) *VOutput {
@@ -741,5 +760,9 @@ func (to *TestVOutput) ToVOutput(t testing.TB) *VOutput {
 		}
 	}
 
+	if to.Address != nil {
+		v.Address = to.Address.ToAddress(t)
+	}
+
 	return v
 }