diff --git a/blockchain/compress.go b/blockchain/compress.go
index 611b9f09923..4495918558f 100644
--- a/blockchain/compress.go
+++ b/blockchain/compress.go
@@ -5,7 +5,7 @@
 package blockchain
 
 import (
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/txscript"
 )
 
@@ -218,7 +218,7 @@ func isPubKey(script []byte) (bool, []byte) {
 
 		// Ensure the public key is valid.
 		serializedPubKey := script[1:34]
-		_, err := btcec.ParsePubKey(serializedPubKey, btcec.S256())
+		_, err := btcec.ParsePubKey(serializedPubKey)
 		if err == nil {
 			return true, serializedPubKey
 		}
@@ -230,7 +230,7 @@ func isPubKey(script []byte) (bool, []byte) {
 
 		// Ensure the public key is valid.
 		serializedPubKey := script[1:66]
-		_, err := btcec.ParsePubKey(serializedPubKey, btcec.S256())
+		_, err := btcec.ParsePubKey(serializedPubKey)
 		if err == nil {
 			return true, serializedPubKey
 		}
@@ -399,7 +399,7 @@ func decompressScript(compressedPkScript []byte) []byte {
 		compressedKey := make([]byte, 33)
 		compressedKey[0] = byte(encodedScriptSize - 2)
 		copy(compressedKey[1:], compressedPkScript[1:])
-		key, err := btcec.ParsePubKey(compressedKey, btcec.S256())
+		key, err := btcec.ParsePubKey(compressedKey)
 		if err != nil {
 			return nil
 		}
diff --git a/blockchain/fullblocktests/generate.go b/blockchain/fullblocktests/generate.go
index 82d3a036e9d..6be3f7ecf15 100644
--- a/blockchain/fullblocktests/generate.go
+++ b/blockchain/fullblocktests/generate.go
@@ -19,7 +19,7 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/blockchain"
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
@@ -198,7 +198,7 @@ type testGenerator struct {
 // makeTestGenerator returns a test generator instance initialized with the
 // genesis block as the tip.
 func makeTestGenerator(params *chaincfg.Params) (testGenerator, error) {
-	privKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), []byte{0x01})
+	privKey, _ := btcec.PrivKeyFromBytes([]byte{0x01})
 	genesis := params.GenesisBlock
 	genesisHash := genesis.BlockHash()
 	return testGenerator{
diff --git a/go.mod b/go.mod
index 7722564f57a..d73fb52214d 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,7 @@
 module github.com/btcsuite/btcd
 
 require (
+	github.com/btcsuite/btcd/btcec/v2 v2.0.0-00010101000000-000000000000
 	github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f
 	github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce
 	github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd
@@ -14,4 +15,13 @@ require (
 	golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37
 )
 
-go 1.16
+require (
+	github.com/aead/siphash v1.0.1 // indirect
+	github.com/btcsuite/snappy-go v1.0.0 // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
+	github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23 // indirect
+)
+
+replace github.com/btcsuite/btcd/btcec/v2 => ./btcec/v2
+
+go 1.17
diff --git a/go.sum b/go.sum
index 4c5a352a892..445fcc9ff0a 100644
--- a/go.sum
+++ b/go.sum
@@ -1,6 +1,7 @@
 github.com/aead/siphash v1.0.1 h1:FwHfE/T45KPKYuuSAKyyvE+oPWcaQ+CUmFW0bPlM+kg=
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
 github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
+github.com/btcsuite/btcd v0.22.0-beta/go.mod h1:9n5ntfhhHQBIhUvlhDvD3Qg6fRUj4jkN0VB8L8svzOA=
 github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f h1:bAs4lUbRJpnnkd9VhRV3jjAVU7DJVjMaK+IsvSeZvFo=
 github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
 github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
@@ -22,6 +23,10 @@ github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
+github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
 github.com/decred/dcrd/lru v1.0.0 h1:Kbsb1SFDsIlaupWPwsPp+dkxiBY1frcS07PCPgotKz8=
 github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
diff --git a/integration/csv_fork_test.go b/integration/csv_fork_test.go
index 31466349669..6750fd090f0 100644
--- a/integration/csv_fork_test.go
+++ b/integration/csv_fork_test.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // This file is ignored during the regular tests due to the following build tag.
+//go:build rpctest
 // +build rpctest
 
 package integration
@@ -15,7 +16,7 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/blockchain"
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/integration/rpctest"
diff --git a/integration/rpctest/memwallet.go b/integration/rpctest/memwallet.go
index 59b0ef4c08a..2acd3c8ef13 100644
--- a/integration/rpctest/memwallet.go
+++ b/integration/rpctest/memwallet.go
@@ -11,7 +11,7 @@ import (
 	"sync"
 
 	"github.com/btcsuite/btcd/blockchain"
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/rpcclient"
@@ -129,10 +129,15 @@ func newMemWallet(net *chaincfg.Params, harnessID uint32) (*memWallet, error) {
 	if err != nil {
 		return nil, err
 	}
-	coinbaseKey, err := coinbaseChild.ECPrivKey()
+	coinbaseKeyOld, err := coinbaseChild.ECPrivKey()
 	if err != nil {
 		return nil, err
 	}
+
+	// Some modules weirdness: we need to conver types here as btcutil
+	// still uses the old version of the module.
+	coinbaseKey, _ := btcec.PrivKeyFromBytes(coinbaseKeyOld.Serialize())
+
 	coinbaseAddr, err := keyToAddr(coinbaseKey, net)
 	if err != nil {
 		return nil, err
@@ -341,11 +346,13 @@ func (m *memWallet) newAddress() (btcutil.Address, error) {
 	if err != nil {
 		return nil, err
 	}
-	privKey, err := childKey.ECPrivKey()
+	privKeyOld, err := childKey.ECPrivKey()
 	if err != nil {
 		return nil, err
 	}
 
+	privKey, _ := btcec.PrivKeyFromBytes(privKeyOld.Serialize())
+
 	addr, err := keyToAddr(privKey, m.net)
 	if err != nil {
 		return nil, err
@@ -514,11 +521,13 @@ func (m *memWallet) CreateTransaction(outputs []*wire.TxOut,
 			return nil, err
 		}
 
-		privKey, err := extendedKey.ECPrivKey()
+		privKeyOld, err := extendedKey.ECPrivKey()
 		if err != nil {
 			return nil, err
 		}
 
+		privKey, _ := btcec.PrivKeyFromBytes(privKeyOld.Serialize())
+
 		sigScript, err := txscript.SignatureScript(tx, i, utxo.pkScript,
 			txscript.SigHashAll, privKey, true)
 		if err != nil {
diff --git a/mempool/mempool_test.go b/mempool/mempool_test.go
index 96d50544176..a401155d03a 100644
--- a/mempool/mempool_test.go
+++ b/mempool/mempool_test.go
@@ -13,7 +13,7 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/blockchain"
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
diff --git a/mempool/policy_test.go b/mempool/policy_test.go
index b9cdbac47aa..b7cfba86ace 100644
--- a/mempool/policy_test.go
+++ b/mempool/policy_test.go
@@ -9,7 +9,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
diff --git a/rpcserver.go b/rpcserver.go
index d184072942f..19b387c1d49 100644
--- a/rpcserver.go
+++ b/rpcserver.go
@@ -29,7 +29,7 @@ import (
 
 	"github.com/btcsuite/btcd/blockchain"
 	"github.com/btcsuite/btcd/blockchain/indexers"
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcjson"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -3512,7 +3512,13 @@ func handleSignMessageWithPrivKey(s *rpcServer, cmd interface{}, closeChan <-cha
 	wire.WriteVarString(&buf, 0, c.Message)
 	messageHash := chainhash.DoubleHashB(buf.Bytes())
 
-	sig, err := btcec.SignCompact(btcec.S256(), wif.PrivKey,
+	// Another instance of modules, weirdness: we'll need to convert things
+	// back over to a private key format we can use.
+	//
+	// TODO(roasbeef): remove after updating btcutil
+	privKey, _ := btcec.PrivKeyFromBytes(wif.PrivKey.Serialize())
+
+	sig, err := btcec.SignCompact(privKey,
 		messageHash, wif.CompressPubKey)
 	if err != nil {
 		return nil, &btcjson.RPCError{
@@ -3707,7 +3713,7 @@ func handleVerifyMessage(s *rpcServer, cmd interface{}, closeChan <-chan struct{
 	wire.WriteVarString(&buf, 0, messageSignatureHeader)
 	wire.WriteVarString(&buf, 0, c.Message)
 	expectedMessageHash := chainhash.DoubleHashB(buf.Bytes())
-	pk, wasCompressed, err := btcec.RecoverCompact(btcec.S256(), sig,
+	pk, wasCompressed, err := btcec.RecoverCompact(sig,
 		expectedMessageHash)
 	if err != nil {
 		// Mirror Bitcoin Core behavior, which treats error in
diff --git a/txscript/engine.go b/txscript/engine.go
index 0814e7eb961..1550579d289 100644
--- a/txscript/engine.go
+++ b/txscript/engine.go
@@ -12,7 +12,7 @@ import (
 	"math/big"
 	"strings"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/wire"
 )
 
diff --git a/txscript/example_test.go b/txscript/example_test.go
index 6e17341c4a6..9d5c7c6a34b 100644
--- a/txscript/example_test.go
+++ b/txscript/example_test.go
@@ -9,7 +9,7 @@ import (
 	"encoding/hex"
 	"fmt"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
@@ -90,7 +90,7 @@ func ExampleSignTxOutput() {
 		fmt.Println(err)
 		return
 	}
-	privKey, pubKey := btcec.PrivKeyFromBytes(btcec.S256(), privKeyBytes)
+	privKey, pubKey := btcec.PrivKeyFromBytes(privKeyBytes)
 	pubKeyHash := btcutil.Hash160(pubKey.SerializeCompressed())
 	addr, err := btcutil.NewAddressPubKeyHash(pubKeyHash,
 		&chaincfg.MainNetParams)
diff --git a/txscript/opcode.go b/txscript/opcode.go
index 4c31be3f75f..708bb2370bc 100644
--- a/txscript/opcode.go
+++ b/txscript/opcode.go
@@ -15,7 +15,7 @@ import (
 
 	"golang.org/x/crypto/ripemd160"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 )
@@ -1929,7 +1929,7 @@ func opcodeCheckSig(op *opcode, data []byte, vm *Engine) error {
 		hash = calcSignatureHash(subScript, hashType, &vm.tx, vm.txIdx)
 	}
 
-	pubKey, err := btcec.ParsePubKey(pkBytes, btcec.S256())
+	pubKey, err := btcec.ParsePubKey(pkBytes)
 	if err != nil {
 		vm.dstack.PushBool(false)
 		return nil
@@ -1939,9 +1939,9 @@ func opcodeCheckSig(op *opcode, data []byte, vm *Engine) error {
 	if vm.hasFlag(ScriptVerifyStrictEncoding) ||
 		vm.hasFlag(ScriptVerifyDERSignatures) {
 
-		signature, err = btcec.ParseDERSignature(sigBytes, btcec.S256())
+		signature, err = btcec.ParseDERSignature(sigBytes)
 	} else {
-		signature, err = btcec.ParseSignature(sigBytes, btcec.S256())
+		signature, err = btcec.ParseSignature(sigBytes)
 	}
 	if err != nil {
 		vm.dstack.PushBool(false)
@@ -2148,11 +2148,9 @@ func opcodeCheckMultiSig(op *opcode, data []byte, vm *Engine) error {
 			if vm.hasFlag(ScriptVerifyStrictEncoding) ||
 				vm.hasFlag(ScriptVerifyDERSignatures) {
 
-				parsedSig, err = btcec.ParseDERSignature(signature,
-					btcec.S256())
+				parsedSig, err = btcec.ParseDERSignature(signature)
 			} else {
-				parsedSig, err = btcec.ParseSignature(signature,
-					btcec.S256())
+				parsedSig, err = btcec.ParseSignature(signature)
 			}
 			sigInfo.parsed = true
 			if err != nil {
@@ -2174,7 +2172,7 @@ func opcodeCheckMultiSig(op *opcode, data []byte, vm *Engine) error {
 		}
 
 		// Parse the pubkey.
-		parsedPubKey, err := btcec.ParsePubKey(pubKey, btcec.S256())
+		parsedPubKey, err := btcec.ParsePubKey(pubKey)
 		if err != nil {
 			continue
 		}
diff --git a/txscript/pkscript.go b/txscript/pkscript.go
index f5b11e6d531..bee83127657 100644
--- a/txscript/pkscript.go
+++ b/txscript/pkscript.go
@@ -5,7 +5,7 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcutil"
diff --git a/txscript/sigcache.go b/txscript/sigcache.go
index d9e4fa6ce10..959240c04da 100644
--- a/txscript/sigcache.go
+++ b/txscript/sigcache.go
@@ -7,7 +7,7 @@ package txscript
 import (
 	"sync"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 )
 
diff --git a/txscript/sigcache_test.go b/txscript/sigcache_test.go
index 5413ea3b2c2..f9e9f270ef3 100644
--- a/txscript/sigcache_test.go
+++ b/txscript/sigcache_test.go
@@ -8,7 +8,7 @@ import (
 	"crypto/rand"
 	"testing"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 )
 
@@ -16,7 +16,7 @@ import (
 // public key and the public key. This function is used to generate randomized
 // test data.
 func genRandomSig() (*chainhash.Hash, *btcec.Signature, *btcec.PublicKey, error) {
-	privKey, err := btcec.NewPrivateKey(btcec.S256())
+	privKey, err := btcec.NewPrivateKey()
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -26,10 +26,7 @@ func genRandomSig() (*chainhash.Hash, *btcec.Signature, *btcec.PublicKey, error)
 		return nil, nil, nil, err
 	}
 
-	sig, err := privKey.Sign(msgHash[:])
-	if err != nil {
-		return nil, nil, nil, err
-	}
+	sig := btcec.Sign(privKey, msgHash[:])
 
 	return &msgHash, sig, privKey.PubKey(), nil
 }
@@ -49,8 +46,8 @@ func TestSigCacheAddExists(t *testing.T) {
 	sigCache.Add(*msg1, sig1, key1)
 
 	// The previously added triplet should now be found within the sigcache.
-	sig1Copy, _ := btcec.ParseSignature(sig1.Serialize(), btcec.S256())
-	key1Copy, _ := btcec.ParsePubKey(key1.SerializeCompressed(), btcec.S256())
+	sig1Copy, _ := btcec.ParseSignature(sig1.Serialize())
+	key1Copy, _ := btcec.ParsePubKey(key1.SerializeCompressed())
 	if !sigCache.Exists(*msg1, sig1Copy, key1Copy) {
 		t.Errorf("previously added item not found in signature cache")
 	}
@@ -73,8 +70,14 @@ func TestSigCacheAddEvictEntry(t *testing.T) {
 
 		sigCache.Add(*msg, sig, key)
 
-		sigCopy, _ := btcec.ParseSignature(sig.Serialize(), btcec.S256())
-		keyCopy, _ := btcec.ParsePubKey(key.SerializeCompressed(), btcec.S256())
+		sigCopy, err := btcec.ParseSignature(sig.Serialize())
+		if err != nil {
+			t.Fatalf("unable to parse sig: %v", err)
+		}
+		keyCopy, err := btcec.ParsePubKey(key.SerializeCompressed())
+		if err != nil {
+			t.Fatalf("unable to parse key: %v", err)
+		}
 		if !sigCache.Exists(*msg, sigCopy, keyCopy) {
 			t.Errorf("previously added item not found in signature" +
 				"cache")
@@ -102,8 +105,8 @@ func TestSigCacheAddEvictEntry(t *testing.T) {
 	}
 
 	// The entry added above should be found within the sigcache.
-	sigNewCopy, _ := btcec.ParseSignature(sigNew.Serialize(), btcec.S256())
-	keyNewCopy, _ := btcec.ParsePubKey(keyNew.SerializeCompressed(), btcec.S256())
+	sigNewCopy, _ := btcec.ParseSignature(sigNew.Serialize())
+	keyNewCopy, _ := btcec.ParsePubKey(keyNew.SerializeCompressed())
 	if !sigCache.Exists(*msgNew, sigNewCopy, keyNewCopy) {
 		t.Fatalf("previously added item not found in signature cache")
 	}
@@ -125,8 +128,8 @@ func TestSigCacheAddMaxEntriesZeroOrNegative(t *testing.T) {
 	sigCache.Add(*msg1, sig1, key1)
 
 	// The generated triplet should not be found.
-	sig1Copy, _ := btcec.ParseSignature(sig1.Serialize(), btcec.S256())
-	key1Copy, _ := btcec.ParsePubKey(key1.SerializeCompressed(), btcec.S256())
+	sig1Copy, _ := btcec.ParseSignature(sig1.Serialize())
+	key1Copy, _ := btcec.ParsePubKey(key1.SerializeCompressed())
 	if sigCache.Exists(*msg1, sig1Copy, key1Copy) {
 		t.Errorf("previously added signature found in sigcache, but" +
 			"shouldn't have been")
diff --git a/txscript/sign.go b/txscript/sign.go
index 138e31cdd4d..293a6c45dc6 100644
--- a/txscript/sign.go
+++ b/txscript/sign.go
@@ -6,9 +6,8 @@ package txscript
 
 import (
 	"errors"
-	"fmt"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcutil"
@@ -28,10 +27,7 @@ func RawTxInWitnessSignature(tx *wire.MsgTx, sigHashes *TxSigHashes, idx int,
 		return nil, err
 	}
 
-	signature, err := key.Sign(hash)
-	if err != nil {
-		return nil, fmt.Errorf("cannot sign tx input: %s", err)
-	}
+	signature := btcec.Sign(key, hash)
 
 	return append(signature.Serialize(), byte(hashType)), nil
 }
@@ -51,7 +47,7 @@ func WitnessSignature(tx *wire.MsgTx, sigHashes *TxSigHashes, idx int, amt int64
 		return nil, err
 	}
 
-	pk := (*btcec.PublicKey)(&privKey.PublicKey)
+	pk := privKey.PubKey()
 	var pkData []byte
 	if compress {
 		pkData = pk.SerializeCompressed()
@@ -73,10 +69,7 @@ func RawTxInSignature(tx *wire.MsgTx, idx int, subScript []byte,
 	if err != nil {
 		return nil, err
 	}
-	signature, err := key.Sign(hash)
-	if err != nil {
-		return nil, fmt.Errorf("cannot sign tx input: %s", err)
-	}
+	signature := btcec.Sign(key, hash)
 
 	return append(signature.Serialize(), byte(hashType)), nil
 }
@@ -95,7 +88,7 @@ func SignatureScript(tx *wire.MsgTx, idx int, subscript []byte, hashType SigHash
 		return nil, err
 	}
 
-	pk := (*btcec.PublicKey)(&privKey.PublicKey)
+	pk := privKey.PubKey()
 	var pkData []byte
 	if compress {
 		pkData = pk.SerializeCompressed()
@@ -270,7 +263,7 @@ sigLoop:
 		tSig := sig[:len(sig)-1]
 		hashType := SigHashType(sig[len(sig)-1])
 
-		pSig, err := btcec.ParseDERSignature(tSig, btcec.S256())
+		pSig, err := btcec.ParseDERSignature(tSig)
 		if err != nil {
 			continue
 		}
@@ -288,7 +281,16 @@ sigLoop:
 			// bad input.
 			pkaddr := addr.(*btcutil.AddressPubKey)
 
-			pubKey := pkaddr.PubKey()
+			pubKeyOld := pkaddr.PubKey()
+
+			// A bit of modules induced weirdness: we need to
+			// conver types here since btcutil is still using the
+			// older version of the module.
+			//
+			// TODO(roasbeef): remove
+			pubKey, _ := btcec.ParsePubKey(
+				pubKeyOld.SerializeCompressed(),
+			)
 
 			// If it matches we put it in the map. We only
 			// can take one signature per public key so if we
diff --git a/txscript/sign_test.go b/txscript/sign_test.go
index b97a8a64d42..1f772fa8100 100644
--- a/txscript/sign_test.go
+++ b/txscript/sign_test.go
@@ -9,7 +9,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
@@ -143,15 +143,14 @@ func TestSignTxOutput(t *testing.T) {
 	for _, hashType := range hashTypes {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeUncompressed()
+			pk := key.PubKey().SerializeUncompressed()
 			address, err := btcutil.NewAddressPubKeyHash(
 				btcutil.Hash160(pk), &chaincfg.TestNet3Params)
 			if err != nil {
@@ -180,15 +179,14 @@ func TestSignTxOutput(t *testing.T) {
 	for _, hashType := range hashTypes {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeUncompressed()
+			pk := key.PubKey().SerializeUncompressed()
 			address, err := btcutil.NewAddressPubKeyHash(
 				btcutil.Hash160(pk), &chaincfg.TestNet3Params)
 			if err != nil {
@@ -241,15 +239,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeCompressed()
+			pk := key.PubKey().SerializeCompressed()
 			address, err := btcutil.NewAddressPubKeyHash(
 				btcutil.Hash160(pk), &chaincfg.TestNet3Params)
 			if err != nil {
@@ -280,15 +277,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeCompressed()
+			pk := key.PubKey().SerializeCompressed()
 			address, err := btcutil.NewAddressPubKeyHash(
 				btcutil.Hash160(pk), &chaincfg.TestNet3Params)
 			if err != nil {
@@ -342,15 +338,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeUncompressed()
+			pk := key.PubKey().SerializeUncompressed()
 			address, err := btcutil.NewAddressPubKey(pk,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -381,15 +376,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeUncompressed()
+			pk := key.PubKey().SerializeUncompressed()
 			address, err := btcutil.NewAddressPubKey(pk,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -442,15 +436,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeCompressed()
+			pk := key.PubKey().SerializeCompressed()
 			address, err := btcutil.NewAddressPubKey(pk,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -481,15 +474,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeCompressed()
+			pk := key.PubKey().SerializeCompressed()
 			address, err := btcutil.NewAddressPubKey(pk,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -543,15 +535,14 @@ func TestSignTxOutput(t *testing.T) {
 	for _, hashType := range hashTypes {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeUncompressed()
+			pk := key.PubKey().SerializeUncompressed()
 			address, err := btcutil.NewAddressPubKeyHash(
 				btcutil.Hash160(pk), &chaincfg.TestNet3Params)
 			if err != nil {
@@ -600,15 +591,14 @@ func TestSignTxOutput(t *testing.T) {
 	for _, hashType := range hashTypes {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeUncompressed()
+			pk := key.PubKey().SerializeUncompressed()
 			address, err := btcutil.NewAddressPubKeyHash(
 				btcutil.Hash160(pk), &chaincfg.TestNet3Params)
 			if err != nil {
@@ -683,15 +673,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeCompressed()
+			pk := key.PubKey().SerializeCompressed()
 			address, err := btcutil.NewAddressPubKeyHash(
 				btcutil.Hash160(pk), &chaincfg.TestNet3Params)
 			if err != nil {
@@ -740,15 +729,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeCompressed()
+			pk := key.PubKey().SerializeCompressed()
 			address, err := btcutil.NewAddressPubKeyHash(
 				btcutil.Hash160(pk), &chaincfg.TestNet3Params)
 			if err != nil {
@@ -822,15 +810,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeUncompressed()
+			pk := key.PubKey().SerializeUncompressed()
 			address, err := btcutil.NewAddressPubKey(pk,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -879,15 +866,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeUncompressed()
+			pk := key.PubKey().SerializeUncompressed()
 			address, err := btcutil.NewAddressPubKey(pk,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -960,15 +946,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeCompressed()
+			pk := key.PubKey().SerializeCompressed()
 			address, err := btcutil.NewAddressPubKey(pk,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -1016,15 +1001,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key, err := btcec.NewPrivateKey(btcec.S256())
+			key, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk := (*btcec.PublicKey)(&key.PublicKey).
-				SerializeCompressed()
+			pk := key.PubKey().SerializeCompressed()
 			address, err := btcutil.NewAddressPubKey(pk,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -1097,15 +1081,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key1, err := btcec.NewPrivateKey(btcec.S256())
+			key1, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk1 := (*btcec.PublicKey)(&key1.PublicKey).
-				SerializeCompressed()
+			pk1 := key1.PubKey().SerializeCompressed()
 			address1, err := btcutil.NewAddressPubKey(pk1,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -1114,15 +1097,14 @@ func TestSignTxOutput(t *testing.T) {
 				break
 			}
 
-			key2, err := btcec.NewPrivateKey(btcec.S256())
+			key2, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey 2 for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk2 := (*btcec.PublicKey)(&key2.PublicKey).
-				SerializeCompressed()
+			pk2 := key2.PubKey().SerializeCompressed()
 			address2, err := btcutil.NewAddressPubKey(pk2,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -1173,15 +1155,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key1, err := btcec.NewPrivateKey(btcec.S256())
+			key1, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk1 := (*btcec.PublicKey)(&key1.PublicKey).
-				SerializeCompressed()
+			pk1 := key1.PubKey().SerializeCompressed()
 			address1, err := btcutil.NewAddressPubKey(pk1,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -1190,15 +1171,14 @@ func TestSignTxOutput(t *testing.T) {
 				break
 			}
 
-			key2, err := btcec.NewPrivateKey(btcec.S256())
+			key2, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey 2 for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk2 := (*btcec.PublicKey)(&key2.PublicKey).
-				SerializeCompressed()
+			pk2 := key2.PubKey().SerializeCompressed()
 			address2, err := btcutil.NewAddressPubKey(pk2,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -1279,15 +1259,14 @@ func TestSignTxOutput(t *testing.T) {
 		for i := range tx.TxIn {
 			msg := fmt.Sprintf("%d:%d", hashType, i)
 
-			key1, err := btcec.NewPrivateKey(btcec.S256())
+			key1, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk1 := (*btcec.PublicKey)(&key1.PublicKey).
-				SerializeCompressed()
+			pk1 := key1.PubKey().SerializeCompressed()
 			address1, err := btcutil.NewAddressPubKey(pk1,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -1296,15 +1275,14 @@ func TestSignTxOutput(t *testing.T) {
 				break
 			}
 
-			key2, err := btcec.NewPrivateKey(btcec.S256())
+			key2, err := btcec.NewPrivateKey()
 			if err != nil {
 				t.Errorf("failed to make privKey 2 for %s: %v",
 					msg, err)
 				break
 			}
 
-			pk2 := (*btcec.PublicKey)(&key2.PublicKey).
-				SerializeCompressed()
+			pk2 := key2.PubKey().SerializeCompressed()
 			address2, err := btcutil.NewAddressPubKey(pk2,
 				&chaincfg.TestNet3Params)
 			if err != nil {
@@ -1635,7 +1613,7 @@ var sigScriptTests = []tstSigScript{
 func TestSignatureScript(t *testing.T) {
 	t.Parallel()
 
-	privKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), privKeyD)
+	privKey, _ := btcec.PrivKeyFromBytes(privKeyD)
 
 nexttest:
 	for i := range sigScriptTests {