asset: add prop tests for AltLeaf[Asset]

In this commit, we add property tests for the AltLeaf validation logic
and the AltLeaf encoder and decoder. We also add Generator functions for
many types, including the Asset type.

Author: jharveyb

asset/asset_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/sha256"
 	"encoding/hex"
+	"reflect"
 	"testing"
 
 	"github.com/btcsuite/btcd/blockchain"
@@ -18,6 +19,7 @@ import (
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/tlv"
 	"github.com/stretchr/testify/require"
+	"pgregory.net/rapid"
 )
 
 var (
@@ -514,6 +516,79 @@ func TestAssetEncoding(t *testing.T) {
 	test.WriteTestVectors(t, generatedTestVectorName, testVectors)
 }
 
+// TestAltLeafEncoding runs a property test for AltLeaf validation, encoding,
+// and decoding.
+func TestAltLeafEncoding(t *testing.T) {
+	t.Run("alt leaf encode/decode", rapid.MakeCheck(testAltLeafEncoding))
+}
+
+// testAltLeafEncoding tests the AltLeaf validation logic, and that a valid
+// AltLeaf can be encoded and decoded correctly.
+func testAltLeafEncoding(t *rapid.T) {
+	protoLeaf := AltLeafGen(t).Draw(t, "alt_leaf")
+	validAltLeafErr := protoLeaf.ValidateAltLeaf()
+
+	// If validation passes, the asset must follow all alt leaf constraints.
+	asserts := []AssetAssert{
+		AssetVersionAssert(V0),
+		AssetGenesisAssert(EmptyGenesis),
+		AssetAmountAssert(0),
+		AssetLockTimeAssert(0),
+		AssetRelativeLockTimeAssert(0),
+		AssetHasSplitRootAssert(false),
+		AssetGroupKeyAssert(nil),
+		AssetHasScriptKeyAssert(true),
+	}
+	assertErr := CheckAssetAsserts(&protoLeaf, asserts...)
+
+	// If the validation method and these assertions behave differently,
+	// either the test or the validation method is incorrect.
+	switch {
+	case validAltLeafErr == nil && assertErr != nil:
+		t.Error(assertErr)
+
+	case validAltLeafErr != nil && assertErr == nil:
+		t.Error(validAltLeafErr)
+
+	default:
+	}
+
+	// Don't test encoding for invalid alt leaves.
+	if validAltLeafErr != nil {
+		return
+	}
+
+	// If the alt leaf is valid, check that it can be encoded without error,
+	// and decoded to an identical alt leaf.
+	// fmt.Println("valid leaf")
+	var buf bytes.Buffer
+	if err := protoLeaf.EncodeAltLeaf(&buf); err != nil {
+		t.Error(err)
+	}
+
+	var decodedLeaf Asset
+	altLeafBytes := bytes.NewReader(buf.Bytes())
+	if err := decodedLeaf.DecodeAltLeaf(altLeafBytes); err != nil {
+		t.Error(err)
+	}
+
+	if !protoLeaf.DeepEqual(&decodedLeaf) {
+		t.Errorf("decoded leaf %v does not match input %v", decodedLeaf,
+			protoLeaf)
+	}
+
+	// Asset.DeepEqual does not inspect UnknownOddTypes, so check for their
+	// equality separately.
+	if !reflect.DeepEqual(
+		protoLeaf.UnknownOddTypes, decodedLeaf.UnknownOddTypes,
+	) {
+
+		t.Errorf("decoded leaf unknown types %v does not match input "+
+			"%v", decodedLeaf.UnknownOddTypes,
+			protoLeaf.UnknownOddTypes)
+	}
+}
+
 // TestTapLeafEncoding asserts that we can properly encode and decode tapLeafs
 // through their TLV serialization, and that invalid tapLeafs are rejected.
 func TestTapLeafEncoding(t *testing.T) {