multi: copied assets shouldn't inherit locktime from inputs

In this commit, we fix an existing bug related to lock times and split
commitments. Before this commit, if an input had a relative lock time,
then when we went to make the new split assets, we would _copy_ that
value into the split. This isn't correct as the input is
valid/confirmed, so we don't need to copy over the lock time
information.

The prior behavior would cause certain classes of spends to fail, as
we would be validating a new root asset that has no lock time, but the
root asset split inserted into the split commitment would be carrying
the old lock time. When verifying the split, we would set the lock times
of the split to that of the new asset:
https://github.com/lightninglabs/taproot-assets/blob/e893dee87e9d8f0de53b8ee9e2527add80df6491/vm/vm.go#L305-L307.

As we copied over the lock time from the input, we would now effectively
invalid the split commitment.

Fixes #1099

Author: Roasbeef

commitment/commitment_test.go

@@ -656,6 +656,43 @@ func TestSplitCommitment(t *testing.T) {
 			},
 			err: nil,
 		},
+		{
+			name: "single input split commitment lock time input",
+			f: func() (*asset.Asset, *SplitLocator,
+				[]*SplitLocator) {
+
+				input := randAsset(
+					t, genesisNormal, groupKeyNormal,
+				)
+				input.Amount = 3
+				input.RelativeLockTime = 1
+				input.LockTime = 1
+
+				root := &SplitLocator{
+					OutputIndex: 0,
+					AssetID:     genesisNormal.ID(),
+					ScriptKey: asset.ToSerialized(
+						input.ScriptKey.PubKey,
+					),
+					Amount: 1,
+				}
+				external := []*SplitLocator{{
+					OutputIndex: 1,
+					AssetID:     genesisNormal.ID(),
+					ScriptKey:   asset.RandSerializedKey(t),
+					Amount:      1,
+				}, {
+
+					OutputIndex: 2,
+					AssetID:     genesisNormal.ID(),
+					ScriptKey:   asset.RandSerializedKey(t),
+					Amount:      1,
+				}}
+
+				return input, root, external
+			},
+			err: nil,
+		},
 		{
 			name: "no external splits",
 			f: func() (*asset.Asset, *SplitLocator, []*SplitLocator) {
@@ -871,6 +908,11 @@ func TestSplitCommitment(t *testing.T) {
 				require.Contains(t, split.SplitAssets, *l)
 				splitAsset := split.SplitAssets[*l]
 
+				// Make sure that the splits don't inherit lock
+				// time information from the root asset.
+				require.Zero(t, splitAsset.LockTime)
+				require.Zero(t, splitAsset.RelativeLockTime)
+
 				// If this is a leaf split, then we need to
 				// ensure that the prev ID is zero.
 				if splitAsset.SplitCommitmentRoot == nil {

commitment/split.go

@@ -210,6 +210,12 @@ func NewSplitCommitment(ctx context.Context, inputs []SplitCommitmentInput,
 		}}
 		assetSplit.SplitCommitmentRoot = nil
 
+		// We'll also make sure to clear out the lock time and relative
+		// lock time from the input. The input at this point is already
+		// valid, so we don't need to inherit the time lock encumbrance.
+		assetSplit.RelativeLockTime = 0
+		assetSplit.LockTime = 0
+
 		splitAssets[*locator] = &SplitAsset{
 			Asset:       *assetSplit,
 			OutputIndex: locator.OutputIndex,

proof/verifier.go

@@ -385,8 +385,11 @@ func CreateOwnershipProofAsset(ownedAsset *asset.Asset,
 	// definitely not have a split commitment. Keeping the split commitment
 	// of the copied owned asset would lead to an issue with the
 	// non-inflation check we have in the VM that takes the split commitment
-	// root sum as the expected total output amount.
+	// root sum as the expected total output amount. We also clear any time
+	// locks, as they don't apply to the ownership proof.
 	outputAsset.SplitCommitmentRoot = nil
+	outputAsset.LockTime = 0
+	outputAsset.RelativeLockTime = 0
 
 	return prevId, outputAsset
 }

tapfreighter/wallet.go

@@ -315,6 +315,11 @@ func createPassivePacket(params *address.ChainParams, passiveAsset *asset.Asset,
 	// asset.
 	outputAsset.SplitCommitmentRoot = nil
 
+	// If this was previously a time locked asset, it's now a simple asset.
+	// So we need to clear out the time locks as well.
+	outputAsset.LockTime = 0
+	outputAsset.RelativeLockTime = 0
+
 	// Clear the output asset witness data. We'll be creating a new witness.
 	outputAsset.PrevWitnesses = []asset.Witness{{
 		PrevID: &vInput.PrevID,