Taproot support

address/address.go

@@ -6,9 +6,9 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/btcsuite/btcd/btcutil/base58"
+	"github.com/btcsuite/btcd/btcutil/bech32"
 	"github.com/btcsuite/btcd/txscript"
-	"github.com/btcsuite/btcutil/base58"
-	"github.com/btcsuite/btcutil/bech32"
 	"github.com/vulpemventures/go-elements/blech32"
 	"github.com/vulpemventures/go-elements/network"
 	"golang.org/x/crypto/ripemd160"
@@ -28,12 +28,15 @@ const (
 	P2Wsh
 	ConfidentialP2Wpkh
 	ConfidentialP2Wsh
+	P2TR
+	ConfidentialP2TR
 
 	P2PkhScript      = 1
 	P2ShScript       = 2
 	P2MultiSigScript = 3
 	P2WpkhScript     = 4
 	P2WshScript      = 5
+	P2TRScript       = 6
 )
 
 // Base58 type defines the structure of a legacy or wrapped segwit address
@@ -161,9 +164,22 @@ func ToBech32(bc *Bech32) (string, error) {
 	combined := make([]byte, len(converted)+1)
 	combined[0] = bc.Version
 	copy(combined[1:], converted)
-	bech, err := bech32.Encode(bc.Prefix, combined)
-	if err != nil {
-		return "", err
+
+	var bech string
+
+	switch bc.Version {
+	case 0:
+		bech, err = bech32.Encode(bc.Prefix, combined)
+		if err != nil {
+			return "", err
+		}
+	case 1:
+		bech, err = bech32.EncodeM(bc.Prefix, combined)
+		if err != nil {
+			return "", err
+		}
+	default:
+		return "", errors.New("unsupported witness version")
 	}
 
 	return bech, nil
@@ -283,7 +299,12 @@ func ToBlech32(bl *Blech32) (string, error) {
 	combined := make([]byte, len(converted)+1)
 	combined[0] = bl.Version
 	copy(combined[1:], converted)
-	blech32Addr, err := blech32.Encode(bl.Prefix, combined)
+	enc, err := blech32.EncodingTypeFromSegwitVersion(bl.Version)
+	if err != nil {
+		return "", err
+	}
+
+	blech32Addr, err := blech32.Encode(bl.Prefix, combined, enc)
 	if err != nil {
 		return "", err
 	}
@@ -482,22 +503,34 @@ func ToOutputScript(address string) ([]byte, error) {
 			AddData(scriptHash).
 			AddOp(txscript.OP_EQUAL).
 			Script()
-	case P2Wpkh, P2Wsh:
+	case P2Wpkh, P2Wsh, P2TR:
 		fromBech32, err := FromBech32(address)
 		if err != nil {
 			return nil, err
 		}
+
+		versionOpcode := byte(txscript.OP_0)
+		if fromBech32.Version == 1 {
+			versionOpcode = txscript.OP_1
+		}
+
 		return txscript.NewScriptBuilder().
-			AddOp(txscript.OP_0).
+			AddOp(versionOpcode).
 			AddData(fromBech32.Program).
 			Script()
-	case ConfidentialP2Wpkh, ConfidentialP2Wsh:
+	case ConfidentialP2Wpkh, ConfidentialP2Wsh, ConfidentialP2TR:
 		fromBlech32, err := FromBlech32(address)
 		if err != nil {
 			return nil, err
 		}
+
+		versionOpcode := byte(txscript.OP_0)
+		if fromBlech32.Version == 1 {
+			versionOpcode = txscript.OP_1
+		}
+
 		return txscript.NewScriptBuilder().
-			AddOp(txscript.OP_0).
+			AddOp(versionOpcode).
 			AddData(fromBlech32.Program).
 			Script()
 	default:
@@ -508,11 +541,13 @@ func ToOutputScript(address string) ([]byte, error) {
 // GetScriptType returns the type of the given script (p2pkh, p2sh, etc.)
 func GetScriptType(script []byte) int {
 	switch script[0] {
-	case txscript.OP_0:
+	case txscript.OP_0: // segwit v0
 		if len(script[2:]) == 20 {
 			return P2WpkhScript
 		}
 		return P2WshScript
+	case txscript.OP_1: // segwit v1 (taproot)
+		return P2TRScript
 	case txscript.OP_HASH160:
 		return P2ShScript
 	case txscript.OP_DUP:
@@ -548,7 +583,8 @@ func IsConfidential(address string) (bool, error) {
 	isConfidential := (addressType == ConfidentialP2Pkh ||
 		addressType == ConfidentialP2Sh ||
 		addressType == ConfidentialP2Wpkh ||
-		addressType == ConfidentialP2Wsh)
+		addressType == ConfidentialP2Wsh ||
+		addressType == ConfidentialP2TR)
 
 	return isConfidential, nil
 }
@@ -562,14 +598,23 @@ func decodeBlech32(address string, net network.Network) (int, error) {
 	if err != nil {
 		return 0, err
 	}
-	switch len(fromBlech32.Program) {
-	case 20:
-		return ConfidentialP2Wpkh, nil
-	case 32:
-		return ConfidentialP2Wsh, nil
-	default:
-		return 0, errors.New("invalid program Length")
+
+	if fromBlech32.Version == 0 {
+		switch len(fromBlech32.Program) {
+		case 20:
+			return ConfidentialP2Wpkh, nil
+		case 32:
+			return ConfidentialP2Wsh, nil
+		default:
+			return 0, errors.New("invalid program Length")
+		}
+	}
+
+	if fromBlech32.Version == 1 {
+		return ConfidentialP2TR, nil
 	}
+
+	return 0, errors.New("invalid segwit version")
 }
 
 func isBech32(address string, net network.Network) bool {
@@ -581,14 +626,23 @@ func decodeBech32(address string, net network.Network) (int, error) {
 	if err != nil {
 		return 0, err
 	}
-	switch len(fromBech32.Program) {
-	case 20:
-		return P2Wpkh, nil
-	case 32:
-		return P2Wsh, nil
-	default:
-		return 0, errors.New("invalid program Length")
+
+	if fromBech32.Version == 0 {
+		switch len(fromBech32.Program) {
+		case 20:
+			return P2Wpkh, nil
+		case 32:
+			return P2Wsh, nil
+		default:
+			return 0, errors.New("invalid program Length")
+		}
+	}
+
+	if fromBech32.Version == 1 {
+		return P2TR, nil
 	}
+
+	return 0, errors.New("invalid segwit version")
 }
 
 func decodeBase58(address string, net network.Network) (int, error) {

address/opcode.go

@@ -2,6 +2,52 @@ package address
 
 import "github.com/btcsuite/btcd/txscript"
 
+// elements tapscript opcodes
+const (
+	OP_SHA256INITIALIZE = 0xc4
+	OP_SHA256UPDATE     = 0xc5
+	OP_SHA256FINALIZE   = 0xc6
+
+	// Introspection opcodes
+	// inputs
+	OP_INSPECTINPUTOUTPOINT     = 0xc7
+	OP_INSPECTINPUTASSET        = 0xc8
+	OP_INSPECTINPUTVALUE        = 0xc9
+	OP_INSPECTINPUTSCRIPTPUBKEY = 0xca
+	OP_INSPECTINPUTSEQUENCE     = 0xcb
+	OP_INSPECTINPUTISSUANCE     = 0xcc
+	OP_PUSHCURRENTINPUTINDEX    = 0xcd
+
+	// outputs
+	OP_INSPECTOUTPUTASSET        = 0xce
+	OP_INSPECTOUTPUTVALUE        = 0xcf
+	OP_INSPECTOUTPUTNONCE        = 0xd0
+	OP_INSPECTOUTPUTSCRIPTPUBKEY = 0xd1
+
+	// transaction
+	OP_INSPECTVERSION    = 0xd2
+	OP_INSPECTLOCKTIME   = 0xd3
+	OP_INSPECTNUMINPUTS  = 0xd4
+	OP_INSPECTNUMOUTPUTS = 0xd5
+	OP_TXWEIGHT          = 0xd6
+
+	// Arithmetic opcodes
+	OP_ADD64                = 0xd7
+	OP_SUB64                = 0xd8
+	OP_MUL64                = 0xd9
+	OP_DIV64                = 0xda
+	OP_NEG64                = 0xdb
+	OP_LESSTHAN64           = 0xdc
+	OP_LESSTHANOREQUAL64    = 0xdd
+	OP_GREATERTHAN64        = 0xde
+	OP_GREATERTHANOREQUAL64 = 0xdf
+
+	// Conversion opcodes
+	OP_SCRIPTNUMTOLE64 = 0xe0
+	OP_LE64TOSCRIPTNUM = 0xe1
+	OP_LE32TOLE64      = 0xe2
+)
+
 // opcodeArray holds details about all possible opcodes such as how many bytes
 // the Opcode and any associated Data should take, its human-readable Name, and
 // the handler function.
@@ -209,8 +255,10 @@ var opcodeArray = [256]Opcode{
 	txscript.OP_NOP9:  {txscript.OP_NOP9, "OP_NOP9", 1},
 	txscript.OP_NOP10: {txscript.OP_NOP10, "OP_NOP10", 1},
 
+	// taproot update
+	txscript.OP_CHECKSIGADD: {txscript.OP_CHECKSIGADD, "OP_CHECKSIGADD", 1},
+
 	// Undefined opcodes.
-	txscript.OP_UNKNOWN186: {txscript.OP_UNKNOWN186, "OP_UNKNOWN186", 1},
 	txscript.OP_UNKNOWN187: {txscript.OP_UNKNOWN187, "OP_UNKNOWN187", 1},
 	txscript.OP_UNKNOWN188: {txscript.OP_UNKNOWN188, "OP_UNKNOWN188", 1},
 	txscript.OP_UNKNOWN189: {txscript.OP_UNKNOWN189, "OP_UNKNOWN189", 1},