proof: update handling of tapscript preimages

Author: jharveyb

proof/records.go

@@ -224,8 +224,14 @@ func CommitmentProofTapSiblingPreimageRecord(
 	preimage **commitment.TapscriptPreimage) tlv.Record {
 
 	sizeFunc := func() uint64 {
-		// 1 byte for the type, and then the pre-image itself.
-		return 1 + uint64(len((*preimage).SiblingPreimage))
+		var buf bytes.Buffer
+		err := commitment.TapscriptPreimageEncoder(
+			&buf, preimage, &[8]byte{},
+		)
+		if err != nil {
+			panic(err)
+		}
+		return uint64(len(buf.Bytes()))
 	}
 	return tlv.MakeDynamicRecord(
 		CommitmentProofTapSiblingPreimageType, preimage, sizeFunc,
@@ -238,10 +244,15 @@ func TapscriptProofTapPreimage1Record(
 	preimage **commitment.TapscriptPreimage) tlv.Record {
 
 	sizeFunc := func() uint64 {
-		// 1 byte for the type, and then the pre-image itself.
-		return 1 + uint64(len((*preimage).SiblingPreimage))
+		var buf bytes.Buffer
+		err := commitment.TapscriptPreimageEncoder(
+			&buf, preimage, &[8]byte{},
+		)
+		if err != nil {
+			panic(err)
+		}
+		return uint64(len(buf.Bytes()))
 	}
-
 	return tlv.MakeDynamicRecord(
 		TapscriptProofTapPreimage1, preimage,
 		sizeFunc, commitment.TapscriptPreimageEncoder,
@@ -253,10 +264,15 @@ func TapscriptProofTapPreimage2Record(
 	preimage **commitment.TapscriptPreimage) tlv.Record {
 
 	sizeFunc := func() uint64 {
-		// 1 byte for the type, and then the pre-image itself.
-		return 1 + uint64(len((*preimage).SiblingPreimage))
+		var buf bytes.Buffer
+		err := commitment.TapscriptPreimageEncoder(
+			&buf, preimage, &[8]byte{},
+		)
+		if err != nil {
+			panic(err)
+		}
+		return uint64(len(buf.Bytes()))
 	}
-
 	return tlv.MakeDynamicRecord(
 		TapscriptProofTapPreimage2, preimage,
 		sizeFunc, commitment.TapscriptPreimageEncoder,

proof/taproot.go

@@ -99,12 +99,12 @@ type TapscriptProof struct {
 // EncodeRecords returns the encoding records for TapscriptProof.
 func (p TapscriptProof) EncodeRecords() []tlv.Record {
 	records := make([]tlv.Record, 0, 3)
-	if p.TapPreimage1 != nil && len(p.TapPreimage1.SiblingPreimage) > 0 {
+	if p.TapPreimage1 != nil && !p.TapPreimage1.IsEmpty() {
 		records = append(records, TapscriptProofTapPreimage1Record(
 			&p.TapPreimage1,
 		))
 	}
-	if p.TapPreimage2 != nil && len(p.TapPreimage2.SiblingPreimage) > 0 {
+	if p.TapPreimage2 != nil && !p.TapPreimage2.IsEmpty() {
 		records = append(records, TapscriptProofTapPreimage2Record(
 			&p.TapPreimage2,
 		))
@@ -373,81 +373,68 @@ func (p TapscriptProof) DeriveTaprootKeys(internalKey *btcec.PublicKey) (
 	// hashes. In this case, the tapscript tree has two elements, with both
 	// of them being leaves.
 	case !p.TapPreimage1.IsEmpty() && !p.TapPreimage2.IsEmpty() &&
-		p.TapPreimage1.SiblingType == commitment.LeafPreimage &&
-		p.TapPreimage2.SiblingType == commitment.LeafPreimage:
+		p.TapPreimage1.Type() == commitment.LeafPreimage &&
+		p.TapPreimage2.Type() == commitment.LeafPreimage:
 
-		leafHash1, err := commitment.TapLeafHash(
-			p.TapPreimage1.SiblingPreimage,
-		)
+		leafHash1, err := p.TapPreimage1.TapHash()
 		if err != nil {
 			return nil, err
 		}
-		leafHash2, err := commitment.TapLeafHash(
-			p.TapPreimage2.SiblingPreimage,
-		)
+
+		leafHash2, err := p.TapPreimage2.TapHash()
 		if err != nil {
 			return nil, err
 		}
 
-		rootHash := commitment.NewTapBranchHash(*leafHash1, *leafHash2)
+		rootHash := asset.NewTapBranchHash(*leafHash1, *leafHash2)
 		tapscriptRoot = rootHash[:]
 
 	// Two pre-images are specified, with both of the pre-images being a
 	// branch. In this case, we don't know how many elements the tree has,
 	// we just care that these are actually branches and the hash up
 	// correctly.
 	case !p.TapPreimage1.IsEmpty() && !p.TapPreimage2.IsEmpty() &&
-		p.TapPreimage1.SiblingType == commitment.BranchPreimage &&
-		p.TapPreimage2.SiblingType == commitment.BranchPreimage:
+		p.TapPreimage1.Type() == commitment.BranchPreimage &&
+		p.TapPreimage2.Type() == commitment.BranchPreimage:
 
-		branch1, err := commitment.TapBranchHash(
-			p.TapPreimage1.SiblingPreimage,
-		)
+		branch1, err := p.TapPreimage1.TapHash()
 		if err != nil {
 			return nil, err
 		}
-		branch2, err := commitment.TapBranchHash(
-			p.TapPreimage2.SiblingPreimage,
-		)
+		branch2, err := p.TapPreimage2.TapHash()
 		if err != nil {
 			return nil, err
 		}
 
-		rootHash := commitment.NewTapBranchHash(*branch1, *branch2)
+		rootHash := asset.NewTapBranchHash(*branch1, *branch2)
 		tapscriptRoot = rootHash[:]
 
 	// Two pre-images are specified, with one of them being a leaf and the
 	// other being a branch. In this case, we have an un-balanced tapscript
 	// tree. We'll verify the first sibling is a leaf, and the other is
 	// actually a branch.
 	case !p.TapPreimage1.IsEmpty() && !p.TapPreimage2.IsEmpty() &&
-		p.TapPreimage1.SiblingType == commitment.LeafPreimage &&
-		p.TapPreimage2.SiblingType == commitment.BranchPreimage:
+		p.TapPreimage1.Type() == commitment.LeafPreimage &&
+		p.TapPreimage2.Type() == commitment.BranchPreimage:
 
-		leafHash, err := commitment.TapLeafHash(
-			p.TapPreimage1.SiblingPreimage,
-		)
+		leafHash, err := p.TapPreimage1.TapHash()
 		if err != nil {
 			return nil, err
 		}
 
-		branchHash, err := commitment.TapBranchHash(
-			p.TapPreimage2.SiblingPreimage,
-		)
+		branchHash, err := p.TapPreimage2.TapHash()
 		if err != nil {
 			return nil, err
 		}
 
-		rootHash := commitment.NewTapBranchHash(*leafHash, *branchHash)
+		rootHash := asset.NewTapBranchHash(*leafHash, *branchHash)
 		tapscriptRoot = rootHash[:]
 
 	// Only a single pre-image was specified, and the pre-image is a leaf.
-	case !p.TapPreimage1.IsEmpty() &&
-		p.TapPreimage1.SiblingType == commitment.BranchPreimage:
+	case !p.TapPreimage1.IsEmpty() && p.TapPreimage2.IsEmpty() &&
+		p.TapPreimage1.Type() == commitment.LeafPreimage:
 
-		tapHash, err := commitment.TapLeafHash(
-			p.TapPreimage1.SiblingPreimage,
-		)
+		tapHash, err := p.TapPreimage1.TapHash()
 		if err != nil {
 			return nil, err
 		}