adjust tapscript proof

Author: keithsue

x/lending/types/dlc.go

@@ -40,23 +40,20 @@ func BuildDLCMeta(borrowerPubKey string, borrowerAuthPubKey string, dcmPubKey st
 
 	liquidationScript, repaymentScript, timeoutRefundScript, _ := GetVaultScripts(borrowerPubKey, borrowerAuthPubKey, dcmPubKey, finalTimeout)
 
-	tapScriptTree := GetTapScriptTree([][]byte{liquidationScript, repaymentScript, timeoutRefundScript})
+	tapscriptTree := GetTapscriptTree([][]byte{liquidationScript, repaymentScript, timeoutRefundScript})
+	proofs := GetThreeLeafTapscriptTreeProofs(tapscriptTree)
 
-	liquidationScriptProof := tapScriptTree.LeafMerkleProofs[0]
-	repaymentScriptProof := tapScriptTree.LeafMerkleProofs[1]
-	timeoutRefundScriptProof := tapScriptTree.LeafMerkleProofs[2]
-
-	liquidationScriptControlBlock, err := GetControlBlock(internalKey, liquidationScriptProof)
+	liquidationScriptControlBlock, err := GetControlBlock(internalKey, proofs[0])
 	if err != nil {
 		return nil, err
 	}
 
-	repaymentScriptControlBlock, err := GetControlBlock(internalKey, repaymentScriptProof)
+	repaymentScriptControlBlock, err := GetControlBlock(internalKey, proofs[1])
 	if err != nil {
 		return nil, err
 	}
 
-	timeoutRefundScriptControlBlock, err := GetControlBlock(internalKey, timeoutRefundScriptProof)
+	timeoutRefundScriptControlBlock, err := GetControlBlock(internalKey, proofs[2])
 	if err != nil {
 		return nil, err
 	}

x/lending/types/taproot.go

@@ -57,8 +57,8 @@ func CreatePubKeyTimeLockScript(pubKey []byte, lockTime int64) ([]byte, error) {
 
 // CreateTaprootAddress creates the taproot address with the given internal key and scripts
 func CreateTaprootAddress(internalKey *secp256k1.PublicKey, scripts [][]byte, params *chaincfg.Params) (string, error) {
-	tapScriptTree := GetTapScriptTree(scripts)
-	scriptRoot := tapScriptTree.RootNode.TapHash()
+	tapscriptTree := GetTapscriptTree(scripts)
+	scriptRoot := tapscriptTree.RootNode.TapHash()
 
 	taprootOutKey := txscript.ComputeTaprootOutputKey(internalKey, scriptRoot[:])
 
@@ -145,7 +145,7 @@ func GetInternalKey(borrowerPubKey []byte, dcmPubKey []byte) *btcec.PublicKey {
 	return btcec.NewPublicKey(&P.X, &P.Y)
 }
 
-func GetTapScriptTree(scripts [][]byte) *txscript.IndexedTapScriptTree {
+func GetTapscriptTree(scripts [][]byte) *txscript.IndexedTapScriptTree {
 	leaves := []txscript.TapLeaf{}
 
 	for _, script := range scripts {
@@ -157,6 +157,29 @@ func GetTapScriptTree(scripts [][]byte) *txscript.IndexedTapScriptTree {
 	return tree
 }
 
+// GetThreeLeafTapscriptTreeProofs gets the tapscript proofs from the given 3-leaf tapscript tree
+// This is a workaround because btcsuite.AssembleTaprootScriptTree generates incorrect proofs if there exist same scripts
+// NOTE: Assume that this is a tapscript tree with three leaves
+// LeafA,LeafB,LeafC:
+// LeafA proof: H(LeafB),H(LeafC)
+// LeafB proof: H(LeafA),H(LeafC)
+// LeafC proof: H(H(LeafA),H(LeafB)) if H(LeafA) <= H(LeafB)
+func GetThreeLeafTapscriptTreeProofs(tapscriptTree *txscript.IndexedTapScriptTree) []txscript.TapscriptProof {
+	leaves := []txscript.TapLeaf{}
+
+	for _, p := range tapscriptTree.LeafMerkleProofs {
+		leaves = append(leaves, p.TapLeaf)
+	}
+
+	rootNode := tapscriptTree.RootNode
+
+	return []txscript.TapscriptProof{
+		newTapscriptProof(leaves[0], rootNode, append(getTapLeafHash(leaves[1]), getTapLeafHash(leaves[2])...)),
+		newTapscriptProof(leaves[1], rootNode, append(getTapLeafHash(leaves[0]), getTapLeafHash(leaves[2])...)),
+		newTapscriptProof(leaves[2], rootNode, getBranchNodeHash(leaves[0], leaves[1])),
+	}
+}
+
 func GetControlBlock(pubKey *secp256k1.PublicKey, proof txscript.TapscriptProof) ([]byte, error) {
 	controlBlock := proof.ToControlBlock(pubKey)
 
@@ -225,3 +248,26 @@ func GetNUMSPoint() *btcec.PublicKey {
 
 	return point
 }
+
+// getTapLeafHash gets hash of the given tap leaf
+func getTapLeafHash(leaf txscript.TapLeaf) []byte {
+	hash := leaf.TapHash()
+	return hash[:]
+}
+
+// getBranchNodeHash gets the branch node hash from the given left and right nodes
+func getBranchNodeHash(left txscript.TapNode, right txscript.TapNode) []byte {
+	tapBranch := txscript.NewTapBranch(left, right)
+	tapBranchHash := tapBranch.TapHash()
+
+	return tapBranchHash[:]
+}
+
+// newTapscriptProof creates a tapscript proof from the given params
+func newTapscriptProof(leaf txscript.TapLeaf, rootNode txscript.TapNode, proof []byte) txscript.TapscriptProof {
+	return txscript.TapscriptProof{
+		TapLeaf:        leaf,
+		RootNode:       rootNode,
+		InclusionProof: proof,
+	}
+}