Merge pull request #743 from lightninglabs/anchorvp-multi-inputs

Multi-input PSBT spend for homogeneous input asset ID

Author: guggero

itest/psbt_test.go

@@ -953,6 +953,163 @@ func testPsbtMultiSend(t *harnessTest) {
 	)
 }
 
+// testMultiInputPsbtSingleAssetID tests to ensure that we can correctly
+// construct and spend a multi-input full value PSBT where each input has the
+// same asset ID.
+//
+// The test works as follows:
+//  1. Mint an asset on the primary tapd node.
+//  2. Send the asset to a secondary tapd node in two different send events.
+//  3. Send the asset back to the primary tapd node in a single multi-input PSBT
+//     send event.
+func testMultiInputPsbtSingleAssetID(t *harnessTest) {
+	var (
+		ctxb        = context.Background()
+		primaryTapd = t.tapd
+	)
+
+	// Mint a single asset.
+	rpcAssets := MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner.Client, primaryTapd,
+		[]*mintrpc.MintAssetRequest{simpleAssets[0]},
+	)
+	rpcAsset := rpcAssets[0]
+
+	// Set up a node that will serve as the final multi input PSBT sender
+	// node.
+	secondaryTapd := setupTapdHarness(
+		t.t, t, t.lndHarness.Bob, t.universeServer,
+	)
+	defer func() {
+		require.NoError(t.t, secondaryTapd.stop(!*noDelete))
+	}()
+
+	// First of two send events from primary (minting) node to secondary
+	// node.
+	genInfo := rpcAsset.AssetGenesis
+	addr, err := secondaryTapd.NewAddr(
+		ctxb, &taprpc.NewAddrRequest{
+			AssetId: genInfo.AssetId,
+			Amt:     1000,
+		},
+	)
+	require.NoError(t.t, err)
+	AssertAddrCreated(t.t, secondaryTapd, rpcAsset, addr)
+
+	// Send the assets to the secondary node.
+	sendResp := sendAssetsToAddr(t, primaryTapd, addr)
+
+	ConfirmAndAssertOutboundTransfer(
+		t.t, t.lndHarness.Miner.Client, primaryTapd, sendResp,
+		genInfo.AssetId, []uint64{4000, 1000}, 0, 1,
+	)
+
+	AssertNonInteractiveRecvComplete(t.t, secondaryTapd, 1)
+
+	// Second of two send events from primary (minting) node to the
+	// secondary node.
+	addr, err = secondaryTapd.NewAddr(
+		ctxb, &taprpc.NewAddrRequest{
+			AssetId: genInfo.AssetId,
+			Amt:     4000,
+		},
+	)
+	require.NoError(t.t, err)
+	AssertAddrCreated(t.t, secondaryTapd, rpcAsset, addr)
+
+	// Send the assets to the secondary node.
+	sendResp = sendAssetsToAddr(t, primaryTapd, addr)
+
+	ConfirmAndAssertOutboundTransfer(
+		t.t, t.lndHarness.Miner.Client, primaryTapd, sendResp,
+		genInfo.AssetId, []uint64{0, 4000}, 1, 2,
+	)
+
+	AssertNonInteractiveRecvComplete(t.t, secondaryTapd, 2)
+
+	t.Logf("Two separate send events complete, now attempting to send " +
+		"back the full amount in a single multi-input PSBT send event")
+
+	// Ensure that the primary node has no assets before we begin.
+	primaryNodeAssets, err := primaryTapd.ListAssets(
+		ctxb, &taprpc.ListAssetRequest{},
+	)
+	require.NoError(t.t, err)
+	require.Empty(t.t, primaryNodeAssets.Assets)
+
+	// We need to derive two keys for the receiver node, one for the new
+	// script key and one for the internal key.
+	receiverScriptKey, receiverAnchorIntKeyDesc := deriveKeys(
+		t.t, primaryTapd,
+	)
+
+	var assetId asset.ID
+	copy(assetId[:], genInfo.AssetId)
+
+	var (
+		chainParams = &address.RegressionNetTap
+		sendAmt     = uint64(5000)
+	)
+
+	vPkt := tappsbt.ForInteractiveSend(
+		assetId, sendAmt, receiverScriptKey, 0,
+		receiverAnchorIntKeyDesc, asset.V0, chainParams,
+	)
+
+	// Next, we'll attempt to fund the PSBT.
+	fundResp := fundPacket(t, secondaryTapd, vPkt)
+	signResp, err := secondaryTapd.SignVirtualPsbt(
+		ctxb, &wrpc.SignVirtualPsbtRequest{
+			FundedPsbt: fundResp.FundedPsbt,
+		},
+	)
+	require.NoError(t.t, err)
+
+	// And finally anchor the PSBT in the BTC chain to complete the
+	// transfer.
+	sendResp, err = secondaryTapd.AnchorVirtualPsbts(
+		ctxb, &wrpc.AnchorVirtualPsbtsRequest{
+			VirtualPsbts: [][]byte{signResp.SignedPsbt},
+		},
+	)
+	require.NoError(t.t, err)
+
+	var (
+		currentTransferIdx = 0
+		numTransfers       = 1
+		numOutputs         = 1
+	)
+	ConfirmAndAssetOutboundTransferWithOutputs(
+		t.t, t.lndHarness.Miner.Client, secondaryTapd,
+		sendResp, genInfo.AssetId,
+		[]uint64{sendAmt}, currentTransferIdx, numTransfers,
+		numOutputs,
+	)
+
+	// This is an interactive transfer. Therefore, we will manually transfer
+	// the proof from the sender to the receiver.
+	_ = sendProof(
+		t, secondaryTapd, primaryTapd,
+		receiverScriptKey.PubKey.SerializeCompressed(), genInfo,
+	)
+
+	// Finally, we make sure that the primary node has the asset.
+	primaryNodeAssets, err = primaryTapd.ListAssets(
+		ctxb, &taprpc.ListAssetRequest{},
+	)
+	require.NoError(t.t, err)
+	require.Len(t.t, primaryNodeAssets.Assets, 1)
+
+	// Ensure that the asset is the one we expect.
+	primaryNodeAsset := primaryNodeAssets.Assets[0]
+
+	require.Equal(t.t, primaryNodeAsset.Amount, sendAmt)
+
+	var foundAssetId asset.ID
+	copy(foundAssetId[:], primaryNodeAsset.AssetGenesis.AssetId)
+	require.Equal(t.t, assetId, foundAssetId)
+}
+
 func deriveKeys(t *testing.T, tapd *tapdHarness) (asset.ScriptKey,
 	keychain.KeyDescriptor) {
 

itest/test_list_on_test.go

@@ -167,6 +167,10 @@ var testCases = []*testCase{
 		name: "psbt multi send",
 		test: testPsbtMultiSend,
 	},
+	{
+		name: "multi input psbt single asset id",
+		test: testMultiInputPsbtSingleAssetID,
+	},
 	{
 		name: "universe REST API",
 		test: testUniverseREST,

rpcserver.go

@@ -1757,30 +1757,28 @@ func (r *rpcServer) AnchorVirtualPsbts(ctx context.Context,
 		return nil, fmt.Errorf("error decoding packet: %w", err)
 	}
 
-	if len(vPacket.Inputs) != 1 {
-		return nil, fmt.Errorf("only one input is currently supported")
-	}
+	// Query the asset store to gather tap commitments for all inputs.
+	inputCommitments := make(tappsbt.InputCommitments, len(vPacket.Inputs))
+	for idx := range vPacket.Inputs {
+		input := vPacket.Inputs[idx]
 
-	inputAsset := vPacket.Inputs[0].Asset()
-	prevID := vPacket.Inputs[0].PrevID
-	inputCommitment, err := r.cfg.AssetStore.FetchCommitment(
-		ctx, inputAsset.ID(), prevID.OutPoint, inputAsset.GroupKey,
-		&inputAsset.ScriptKey, true,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("error fetching input commitment: %w",
-			err)
-	}
+		inputAsset := input.Asset()
+		prevID := input.PrevID
+
+		inputCommitment, err := r.cfg.AssetStore.FetchCommitment(
+			ctx, inputAsset.ID(), prevID.OutPoint,
+			inputAsset.GroupKey, &inputAsset.ScriptKey, true,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("error fetching input "+
+				"commitment: %w", err)
+		}
 
-	rpcsLog.Debugf("Selected commitment for anchor point %v, requesting "+
-		"delivery", inputCommitment.AnchorPoint)
+		inputCommitments[idx] = inputCommitment.Commitment
+	}
 
 	resp, err := r.cfg.ChainPorter.RequestShipment(
-		tapfreighter.NewPreSignedParcel(
-			vPacket, tappsbt.InputCommitments{
-				0: inputCommitment.Commitment,
-			},
-		),
+		tapfreighter.NewPreSignedParcel(vPacket, inputCommitments),
 	)
 	if err != nil {
 		return nil, fmt.Errorf("error requesting delivery: %w", err)

tapscript/send.go

@@ -506,32 +506,50 @@ func PrepareOutputAssets(ctx context.Context, vPkt *tappsbt.VPacket) error {
 	)
 
 	if isFullValueInteractiveSend {
-		if len(inputs) != 1 {
-			return fmt.Errorf("full value interactive send " +
-				"must have exactly one input")
+		// Sum the total amount of the input assets.
+		inputsAmountSum := uint64(0)
+		for idx := range inputs {
+			input := inputs[idx]
+
+			// At the moment, we need to ensure that all inputs have
+			// the same asset ID. We've already checked that above,
+			// but we will do it again here for clarity.
+			if inputs[idx].Asset().ID() != assetID {
+				return fmt.Errorf("multiple input assets " +
+					"must have the same asset ID")
+			}
+
+			inputsAmountSum += input.Asset().Amount
 		}
 
-		// TODO(ffranr): Add support for interactive full value multiple
-		// input spend.
-		input := inputs[0]
-		vOut := outputs[recipientIndex]
+		// At this point we know that each input has the same asset ID
+		// we therefore arbitrarily select the first input as our
+		// template output asset.
+		firstInput := inputs[0]
 
 		// We'll now create a new copy of the old asset, swapping out
 		// the script key. We blank out the tweaked key information as
 		// this is now an external asset.
-		vOut.Asset = input.Asset().Copy()
+		vOut := outputs[recipientIndex]
+		vOut.Asset = firstInput.Asset().Copy()
+		vOut.Asset.Amount = inputsAmountSum
 		vOut.Asset.ScriptKey = vOut.ScriptKey
 
-		// Record the PrevID of the input asset in a Witness for the new
-		// asset. This Witness still needs a valid signature for the new
-		// asset to be valid.
-		vOut.Asset.PrevWitnesses = []asset.Witness{
-			{
+		// Gather previous witnesses from the input assets.
+		prevWitnesses := make([]asset.Witness, len(inputs))
+		for idx := range inputs {
+			input := inputs[idx]
+
+			// Record the PrevID of the input asset in a Witness for
+			// the new asset. This Witness still needs a valid
+			// signature for the new asset to be valid.
+			prevWitnesses[idx] = asset.Witness{
 				PrevID:          &input.PrevID,
 				TxWitness:       nil,
 				SplitCommitment: nil,
-			},
+			}
 		}
+		vOut.Asset.PrevWitnesses = prevWitnesses
 
 		// Adjust the version for the requested send type.
 		vOut.Asset.Version = vOut.AssetVersion