diff --git a/src/secp256k1/CMakeLists.txt b/src/secp256k1/CMakeLists.txt
index 501946ca5..3a8289c53 100644
--- a/src/secp256k1/CMakeLists.txt
+++ b/src/secp256k1/CMakeLists.txt
@@ -1,397 +1,398 @@
 # Copyright (c) 2017 The Bitcoin developers
 
 cmake_minimum_required(VERSION 3.16)
 project(secp256k1 LANGUAGES C VERSION 0.1.0)
 
 # Add path for custom modules when building as a standalone project
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
 
 # Default to RelWithDebInfo configuration
 if(NOT CMAKE_BUILD_TYPE)
 	set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
 		"Select the configuration for the build" FORCE)
 	set(__NO_USER_CMAKE_BUILD_TYPE ON CACHE BOOL "True if the user didn't set a build type on the command line")
 endif()
 
 option(SECP256K1_ENABLE_COVERAGE "Enable coverage" OFF)
 option(SECP256K1_ENABLE_BRANCH_COVERAGE "Enable branch coverage" OFF)
 
 include(AddCompilerFlags)
 
 if(SECP256K1_ENABLE_COVERAGE)
 	include(Coverage)
 
 	enable_coverage(${SECP256K1_ENABLE_BRANCH_COVERAGE})
 
 	exclude_from_coverage("${CMAKE_CURRENT_SOURCE_DIR}/src/bench")
 
 	# If no build type is manually defined, override the optimization level.
 	# Otherwise, alert the user than the coverage result might be useless.
 	if(__NO_USER_CMAKE_BUILD_TYPE)
 		set_c_optimization_level(0)
 	else()
 		message(WARNING "It is advised to not enforce CMAKE_BUILD_TYPE to get the best coverage results")
 	endif()
 
 	set(COVERAGE 1)
 endif()
 
 
 
 # libsecp256k1 use a different set of flags.
 add_c_compiler_flags(
 	-pedantic
 	-Wall
 	-Wextra
 	-Wcast-align
 	-Wshadow
 	-Wno-unused-function
 	-Wno-overlength-strings
 	-std=c89
 	-Wnested-externs
 	-Wstrict-prototypes
 	-Wno-long-long
 )
 
 # Default visibility is hidden on all targets.
 set(CMAKE_C_VISIBILITY_PRESET hidden)
 
 include_directories(
 	.
 	src
 	# For the config
 	${CMAKE_CURRENT_BINARY_DIR}/src
 )
 
 # The library
 add_library(secp256k1 src/secp256k1.c)
 target_include_directories(secp256k1 PUBLIC include)
 
 set(SECP256K1_PUBLIC_HEADERS
 	include/secp256k1.h
 	include/secp256k1_preallocated.h
 )
 
 option(SECP256K1_ENABLE_BIGNUM "Use the GMP bignum implementation" OFF)
 if(SECP256K1_ENABLE_BIGNUM)
 	# We need to link in GMP
 	find_package(GMP REQUIRED)
 	target_link_libraries(secp256k1 GMP::gmp)
 	set(USE_NUM_GMP 1)
 	set(USE_FIELD_INV_NUM 1)
 	set(USE_SCALAR_INV_NUM 1)
 else()
 	set(USE_NUM_NONE 1)
 	set(USE_FIELD_INV_BUILTIN 1)
 	set(USE_SCALAR_INV_BUILTIN 1)
 endif()
 
 # Guess the target architecture, within the ones with supported ASM.
 # First check if the CMAKE_C_COMPILER_TARGET is set (should be when
 # cross compiling), then CMAKE_SYSTEM_PROCESSOR as a fallback if meaningful
 # (this is not the case for ARM as the content is highly non standard).
 if(CMAKE_C_COMPILER_TARGET MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
 	set(SECP256K1_ASM_BUILD_TARGET "x86_64")
 	set(SECP256K1_DEFAULT_USE_ASM ON)
 elseif(CMAKE_C_COMPILER_TARGET MATCHES "arm-linux-gnueabihf")
 	set(SECP256K1_ASM_BUILD_TARGET "arm-linux-gnueabihf")
 	set(SECP256K1_DEFAULT_USE_ASM ON)
 endif()
 
 # Enable ASM by default only if we are building for a compatible target.
 # The user can still enable/disable it manually if needed.
 option(SECP256K1_USE_ASM "Use assembly" ${SECP256K1_DEFAULT_USE_ASM})
 
 if(SECP256K1_USE_ASM)
 	macro(unsupported_asm_error)
 		message(FATAL_ERROR
 			"Assembly is enabled, but not supported for your target architecture."
 			"Re-run cmake with -DSECP256K1_USE_ASM=OFF to disable ASM support."
 		)
 	endmacro()
 
 	if(SECP256K1_ASM_BUILD_TARGET MATCHES "x86_64")
 		# We check if amd64 asm is supported.
 		check_c_source_compiles("
 			#include <stdint.h>
 			int main() {
 				uint64_t a = 11, tmp;
 				__asm__ __volatile__(\"movq \$0x100000000,%1; mulq %%rsi\" : \"+a\"(a) : \"S\"(tmp) : \"cc\", \"%rdx\");
 				return 0;
 			}
 		" USE_ASM_X86_64)
 
 		if(NOT USE_ASM_X86_64)
 			unsupported_asm_error()
 		endif()
 	elseif(SECP256K1_ASM_BUILD_TARGET MATCHES "arm-linux-gnueabihf")
 		enable_language(ASM)
 		set(USE_EXTERNAL_ASM 1)
 		add_library(secp256k1_common src/asm/field_10x26_arm.s)
 		target_link_libraries(secp256k1 secp256k1_common)
 	else()
 		unsupported_asm_error()
 	endif()
 endif()
 
 set(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY "" CACHE STRING "Test-only override of the (autodetected by the C code) \"widemul\" setting (can be int64 or int128)")
 if(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY STREQUAL "int128")
 	message(STATUS "Force the use of the (unsigned) __int128 based wide multiplication implementation")
 	target_compile_definitions(secp256k1 PUBLIC USE_FORCE_WIDEMUL_INT128=1)
 elseif(SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY STREQUAL "int64")
 	message(STATUS "Force the use of the (u)int64_t based wide multiplication implementation")
 	target_compile_definitions(secp256k1 PUBLIC USE_FORCE_WIDEMUL_INT64=1)
 endif()
 
 option(SECP256K1_BUILD_TEST "Build secp256k1's unit tests" ON)
 include(CMakeDependentOption)
 cmake_dependent_option(
 	SECP256K1_BUILD_OPENSSL_TESTS "Build the OpenSSL tests" ON
 	SECP256K1_BUILD_TEST ON
 )
 if(SECP256K1_BUILD_OPENSSL_TESTS)
 	include(BrewHelper)
 	find_brew_prefix(OPENSSL_ROOT_DIR openssl)
 	find_package(OpenSSL COMPONENTS Crypto)
 	if(NOT OpenSSL_FOUND)
 		message(FATAL_ERROR
 			"OpenSSL is not found, but is required for some tests. You can disable them by passing -DSECP256K1_BUILD_OPENSSL_TESTS=OFF."
 		)
 	endif()
 	set(ENABLE_OPENSSL_TESTS 1)
 endif()
 
 # Executable internal to secp256k1 need to have the HAVE_CONFIG_H define set.
 # For convenience, we wrap this into a function.
 function(link_secp256k1_internal NAME)
 	target_link_libraries(${NAME} secp256k1)
 	target_compile_definitions(${NAME} PRIVATE HAVE_CONFIG_H SECP256K1_BUILD)
 	if(SECP256K1_BUILD_OPENSSL_TESTS)
 		target_link_libraries(${NAME} OpenSSL::Crypto)
 	endif()
 endfunction(link_secp256k1_internal)
 
 include(InstallationHelper)
 
 # Phony target to build benchmarks
 add_custom_target(bench-secp256k1)
 
 function(add_secp256k1_bench NAME)
 	set(EXECUTABLE_NAME "${NAME}-bench")
 	add_executable(${EXECUTABLE_NAME} ${ARGN})
 	link_secp256k1_internal(${EXECUTABLE_NAME})
 
 	set(BENCH_NAME "bench-secp256k1-${NAME}")
 	add_custom_target(${BENCH_NAME}
 		COMMENT "Benchmarking libsecp256k1 ${NAME}"
 		COMMAND ${EXECUTABLE_NAME}
 		USES_TERMINAL
 	)
 	add_dependencies(bench-secp256k1 ${BENCH_NAME})
 
 	install_target("${EXECUTABLE_NAME}"
 		COMPONENT secp256k1-bench
 		EXCLUDE_FROM_ALL
 	)
 endfunction(add_secp256k1_bench)
 
 # ECDH module
 option(SECP256K1_ENABLE_MODULE_ECDH "Build libsecp256k1's ECDH module" OFF)
 if(SECP256K1_ENABLE_MODULE_ECDH)
 	set(ENABLE_MODULE_ECDH 1)
 	add_secp256k1_bench(ecdh src/bench_ecdh.c)
 	list(APPEND SECP256K1_PUBLIC_HEADERS include/secp256k1_ecdh.h)
 endif()
 
 # MultiSet module
 option(SECP256K1_ENABLE_MODULE_MULTISET "Build libsecp256k1's MULTISET module" OFF)
 if(SECP256K1_ENABLE_MODULE_MULTISET)
     set(ENABLE_MODULE_MULTISET 1)
 	add_secp256k1_bench(multiset src/bench_multiset.c)
 	list(APPEND SECP256K1_PUBLIC_HEADERS include/secp256k1_multiset.h)
 endif()
 
 # Recovery module
 option(SECP256K1_ENABLE_MODULE_RECOVERY "Build libsecp256k1's recovery module" ON)
 if(SECP256K1_ENABLE_MODULE_RECOVERY)
 	set(ENABLE_MODULE_RECOVERY 1)
 	add_secp256k1_bench(recover src/bench_recover.c)
 	list(APPEND SECP256K1_PUBLIC_HEADERS include/secp256k1_recovery.h)
 endif()
 
 # Schnorr module
 option(SECP256K1_ENABLE_MODULE_SCHNORR "Build libsecp256k1's Schnorr module" ON)
 if(SECP256K1_ENABLE_MODULE_SCHNORR)
 	set(ENABLE_MODULE_SCHNORR 1)
 	list(APPEND SECP256K1_PUBLIC_HEADERS include/secp256k1_schnorr.h)
 endif()
 
 # Extrakeys module
 option(SECP256K1_ENABLE_MODULE_EXTRAKEYS "Build libsecp256k1's Extrakeys module" OFF)
 if(SECP256K1_ENABLE_MODULE_EXTRAKEYS)
 	set(ENABLE_MODULE_EXTRAKEYS 1)
 	list(APPEND SECP256K1_PUBLIC_HEADERS include/secp256k1_extrakeys.h)
 endif()
 
 # Schnorrsig module
 option(SECP256K1_ENABLE_MODULE_SCHNORRSIG "Build libsecp256k1's Schnorrsig module" OFF)
 if(SECP256K1_ENABLE_MODULE_SCHNORRSIG)
 	if(NOT SECP256K1_ENABLE_MODULE_EXTRAKEYS)
 		message(FATAL_ERROR "The module Schnorrsig require Extrakeys. Try running cmake using -DSECP256K1_ENABLE_MODULE_EXTRAKEYS=On")
 	endif()
 	set(ENABLE_MODULE_SCHNORRSIG 1)
+	add_secp256k1_bench(schnorrsig src/bench_schnorrsig.c)
 	list(APPEND SECP256K1_PUBLIC_HEADERS include/secp256k1_schnorrsig.h)
 endif()
 
 # External default callbacks
 option(SECP256K1_ENABLE_EXTERNAL_DEFAULT_CALLBACKS "Enable external default callbacks" OFF)
 if(SECP256K1_ENABLE_EXTERNAL_DEFAULT_CALLBACKS)
 	set(USE_EXTERNAL_DEFAULT_CALLBACKS 1)
 endif()
 
 # Endomorphism
 option(SECP256K1_ENABLE_ENDOMORPHISM "Enable endomorphism" OFF)
 if(SECP256K1_ENABLE_ENDOMORPHISM)
 	set(USE_ENDOMORPHISM 1)
 endif()
 
 # Make the emult window size customizable.
 set(SECP256K1_ECMULT_WINDOW_SIZE 15 CACHE STRING "Window size for ecmult precomputation for verification, specified as integer in range [2..24].")
 if(${SECP256K1_ECMULT_WINDOW_SIZE} LESS 2 OR ${SECP256K1_ECMULT_WINDOW_SIZE} GREATER 24)
 	message(FATAL_ERROR "SECP256K1_ECMULT_WINDOW_SIZE must be an integer in range [2..24]")
 endif()
 
 set(SECP256K1_ECMULT_GEN_PRECISION 4 CACHE STRING "Precision bits to tune the precomputed table size for signing.")
 set(VALID_PRECISIONS 2 4 8)
 if(NOT ${SECP256K1_ECMULT_GEN_PRECISION} IN_LIST VALID_PRECISIONS)
 	message(FATAL_ERROR "SECP256K1_ECMULT_GEN_PRECISION not 2, 4, 8")
 endif()
 
 # Static precomputation for elliptic curve multiplication
 option(SECP256K1_ECMULT_STATIC_PRECOMPUTATION "Precompute libsecp256k1's elliptic curve multiplication tables" ON)
 if(SECP256K1_ECMULT_STATIC_PRECOMPUTATION)
 	set(USE_ECMULT_STATIC_PRECOMPUTATION 1)
 
 	include(NativeExecutable)
 	native_add_cmake_flags(
 		"-DSECP256K1_ECMULT_WINDOW_SIZE=${SECP256K1_ECMULT_WINDOW_SIZE}"
 		"-DSECP256K1_ECMULT_GEN_PRECISION=${SECP256K1_ECMULT_GEN_PRECISION}"
 		"-DSECP256K1_USE_ASM=OFF"
 		"-DSECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY=${SECP256K1_TEST_OVERRIDE_WIDE_MULTIPLY}"
 	)
 	add_native_executable(gen_context src/gen_context.c)
 
 	add_custom_command(
 		OUTPUT src/ecmult_static_context.h
 		COMMAND gen_context
 	)
 
 	target_sources(secp256k1 PRIVATE src/ecmult_static_context.h)
 endif()
 
 # If this project is not the top level project, then don't install by default
 get_directory_property(SECP256K1_PARENT_DIRECTORY PARENT_DIRECTORY)
 if(SECP256K1_PARENT_DIRECTORY)
   set(SECP256K1_INSTALL_EXCLUDE_FROM_ALL EXCLUDE_FROM_ALL)
 endif()
 
 if(BUILD_SHARED_LIBS)
 	install_shared_library(secp256k1
 		PUBLIC_HEADER ${SECP256K1_PUBLIC_HEADERS}
 		${SECP256K1_INSTALL_EXCLUDE_FROM_ALL}
 	)
 else()
 	set_property(TARGET secp256k1 PROPERTY PUBLIC_HEADER ${SECP256K1_PUBLIC_HEADERS})
 	install_target(secp256k1 ${SECP256K1_INSTALL_EXCLUDE_FROM_ALL})
 endif()
 
 # Generate the config
 configure_file(src/libsecp256k1-config.h.cmake.in src/libsecp256k1-config.h ESCAPE_QUOTES)
 target_compile_definitions(secp256k1 PRIVATE HAVE_CONFIG_H SECP256K1_BUILD)
 
 # Build the Java binding
 option(SECP256K1_ENABLE_JNI "Enable the Java Native Interface binding" OFF)
 if(SECP256K1_ENABLE_JNI)
 	if(NOT SECP256K1_ENABLE_MODULE_ECDH)
 		message(FATAL_ERROR "The secp256k1 JNI support requires ECDH. Try again with -DSECP256K1_ENABLE_MODULE_ECDH=ON.")
 	endif()
 
 	find_package(Java REQUIRED)
 	find_package(JNI REQUIRED)
 	include(UseJava)
 
 	add_library(secp256k1_jni SHARED
 		src/java/org_bitcoin_NativeSecp256k1.c
 		src/java/org_bitcoin_Secp256k1Context.c
 	)
 
 	install_shared_library(secp256k1_jni ${SECP256K1_INSTALL_EXCLUDE_FROM_ALL})
 
 	target_include_directories(secp256k1_jni PUBLIC ${JNI_INCLUDE_DIRS})
 	# As per CMake documentation: the POSITION_INDEPENDENT_CODE property is set
 	# when a target is created. It defaults to True for SHARED or MODULE library
 	# targets and False otherwise.
 	# The secp256ki_jni library being shared, the property is set and it will
 	# build with PIC enabled. But the secp256k1 dependency might not have the
 	# property set, so it's associated source files won't be built with PIC
 	# enabled. That would cause the linker to fail.
 	# Forcing the property for the secp256k1 library fixes the issue.
 	set_target_properties(secp256k1 PROPERTIES POSITION_INDEPENDENT_CODE ON)
 	link_secp256k1_internal(secp256k1_jni)
 endif()
 
 # Tests
 if(SECP256K1_BUILD_TEST)
 	include(TestSuite)
 	create_test_suite(secp256k1)
 
 	function(create_secp256k1_test NAME FILES)
 		add_test_to_suite(secp256k1 ${NAME} EXCLUDE_FROM_ALL ${FILES})
 		link_secp256k1_internal(${NAME})
 	endfunction()
 
 	create_secp256k1_test(secp256k1-tests src/tests.c)
 	create_secp256k1_test(secp256k1-exhaustive_tests src/tests_exhaustive.c)
 
 	# This should not be enabled at the same time as coverage is.
 	# The VERIFY failure branch is not expected to be reached, so it would make
 	# coverage appear lower if set.
 	if(NOT SECP256K1_ENABLE_COVERAGE)
 		target_compile_definitions(secp256k1-tests PRIVATE VERIFY)
 		target_compile_definitions(secp256k1-exhaustive_tests PRIVATE VERIFY)
 	endif()
 
 	if(SECP256K1_ENABLE_JNI)
 		set(SECP256k1_JNI_TEST_JAR "secp256k1-jni-test")
 
 		set(CMAKE_JNI_TARGET TRUE)
 		add_jar(secp256k1-jni-test-jar
 			SOURCES
 				src/java/org/bitcoin/NativeSecp256k1.java
 				src/java/org/bitcoin/NativeSecp256k1Test.java
 				src/java/org/bitcoin/NativeSecp256k1Util.java
 				src/java/org/bitcoin/Secp256k1Context.java
 			ENTRY_POINT org/bitcoin/NativeSecp256k1Test
 			OUTPUT_NAME "${SECP256k1_JNI_TEST_JAR}"
 		)
 		add_dependencies(secp256k1-jni-test-jar secp256k1_jni)
 
 		add_custom_target(check-secp256k1-java
 			COMMAND
 				"${Java_JAVA_EXECUTABLE}"
 				"-Djava.library.path=${CMAKE_CURRENT_BINARY_DIR}"
 				"-jar"
 				"${SECP256k1_JNI_TEST_JAR}.jar"
 			WORKING_DIRECTORY
 				"${CMAKE_CURRENT_BINARY_DIR}"
 		)
 		add_dependencies(check-secp256k1-java secp256k1-jni-test-jar)
 		add_dependencies(check-secp256k1 check-secp256k1-java)
 	endif()
 endif(SECP256K1_BUILD_TEST)
 
 # Benchmarks
 add_secp256k1_bench(verify src/bench_verify.c)
 add_secp256k1_bench(sign src/bench_sign.c)
 add_secp256k1_bench(internal src/bench_internal.c)
 add_secp256k1_bench(ecmult src/bench_ecmult.c)
diff --git a/src/secp256k1/src/bench_schnorrsig.c b/src/secp256k1/src/bench_schnorrsig.c
new file mode 100644
index 000000000..315f5af28
--- /dev/null
+++ b/src/secp256k1/src/bench_schnorrsig.c
@@ -0,0 +1,102 @@
+/**********************************************************************
+ * Copyright (c) 2018-2020 Andrew Poelstra, Jonas Nick                *
+ * Distributed under the MIT software license, see the accompanying   *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#include <string.h>
+#include <stdlib.h>
+
+
+#include "include/secp256k1.h"
+#include "include/secp256k1_schnorrsig.h"
+#include "util.h"
+#include "bench.h"
+
+typedef struct {
+    secp256k1_context *ctx;
+    int n;
+
+    const secp256k1_keypair **keypairs;
+    const unsigned char **pk;
+    const unsigned char **sigs;
+    const unsigned char **msgs;
+} bench_schnorrsig_data;
+
+void bench_schnorrsig_sign(void* arg, int iters) {
+    bench_schnorrsig_data *data = (bench_schnorrsig_data *)arg;
+    int i;
+    unsigned char msg[32] = "benchmarkexamplemessagetemplate";
+    unsigned char sig[64];
+
+    for (i = 0; i < iters; i++) {
+        msg[0] = i;
+        msg[1] = i >> 8;
+        CHECK(secp256k1_schnorrsig_sign(data->ctx, sig, msg, data->keypairs[i], NULL, NULL));
+    }
+}
+
+void bench_schnorrsig_verify(void* arg, int iters) {
+    bench_schnorrsig_data *data = (bench_schnorrsig_data *)arg;
+    int i;
+
+    for (i = 0; i < iters; i++) {
+        secp256k1_xonly_pubkey pk;
+        CHECK(secp256k1_xonly_pubkey_parse(data->ctx, &pk, data->pk[i]) == 1);
+        CHECK(secp256k1_schnorrsig_verify(data->ctx, data->sigs[i], data->msgs[i], &pk));
+    }
+}
+
+int main(void) {
+    int i;
+    bench_schnorrsig_data data;
+    int iters = get_iters(10000);
+
+    data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN);
+    data.keypairs = (const secp256k1_keypair **)malloc(iters * sizeof(secp256k1_keypair *));
+    data.pk = (const unsigned char **)malloc(iters * sizeof(unsigned char *));
+    data.msgs = (const unsigned char **)malloc(iters * sizeof(unsigned char *));
+    data.sigs = (const unsigned char **)malloc(iters * sizeof(unsigned char *));
+
+    for (i = 0; i < iters; i++) {
+        unsigned char sk[32];
+        unsigned char *msg = (unsigned char *)malloc(32);
+        unsigned char *sig = (unsigned char *)malloc(64);
+        secp256k1_keypair *keypair = (secp256k1_keypair *)malloc(sizeof(*keypair));
+        unsigned char *pk_char = (unsigned char *)malloc(32);
+        secp256k1_xonly_pubkey pk;
+        msg[0] = sk[0] = i;
+        msg[1] = sk[1] = i >> 8;
+        msg[2] = sk[2] = i >> 16;
+        msg[3] = sk[3] = i >> 24;
+        memset(&msg[4], 'm', 28);
+        memset(&sk[4], 's', 28);
+
+        data.keypairs[i] = keypair;
+        data.pk[i] = pk_char;
+        data.msgs[i] = msg;
+        data.sigs[i] = sig;
+
+        CHECK(secp256k1_keypair_create(data.ctx, keypair, sk));
+        CHECK(secp256k1_schnorrsig_sign(data.ctx, sig, msg, keypair, NULL, NULL));
+        CHECK(secp256k1_keypair_xonly_pub(data.ctx, &pk, NULL, keypair));
+        CHECK(secp256k1_xonly_pubkey_serialize(data.ctx, pk_char, &pk) == 1);
+    }
+
+    run_benchmark("schnorrsig_sign", bench_schnorrsig_sign, NULL, NULL, (void *) &data, 10, iters);
+    run_benchmark("schnorrsig_verify", bench_schnorrsig_verify, NULL, NULL, (void *) &data, 10, iters);
+
+    for (i = 0; i < iters; i++) {
+        free((void *)data.keypairs[i]);
+        free((void *)data.pk[i]);
+        free((void *)data.msgs[i]);
+        free((void *)data.sigs[i]);
+    }
+    free(data.keypairs);
+    free(data.pk);
+    free(data.msgs);
+    free(data.sigs);
+
+    secp256k1_context_destroy(data.ctx);
+    return 0;
+}
diff --git a/src/secp256k1/src/libsecp256k1-config.h.cmake.in b/src/secp256k1/src/libsecp256k1-config.h.cmake.in
index 54934fe15..06e3d477b 100644
--- a/src/secp256k1/src/libsecp256k1-config.h.cmake.in
+++ b/src/secp256k1/src/libsecp256k1-config.h.cmake.in
@@ -1,41 +1,43 @@
 /* Copyright (c) 2017 The Bitcoin developers */
 
 #ifndef LIBSECP256K1_CONFIG_H
 #define LIBSECP256K1_CONFIG_H
 
 #cmakedefine HAVE___INT128
 
 #cmakedefine USE_NUM_GMP
 #cmakedefine USE_FIELD_INV_NUM
 #cmakedefine USE_SCALAR_INV_NUM
 
 #cmakedefine USE_NUM_NONE
 #cmakedefine USE_FIELD_INV_BUILTIN
 #cmakedefine USE_SCALAR_INV_BUILTIN
 
 #cmakedefine USE_SCALAR_4X64
 #cmakedefine USE_FIELD_5X52
 
 #cmakedefine USE_SCALAR_8X32
 #cmakedefine USE_FIELD_10X26
 
 #cmakedefine USE_ASM_X86_64
 #cmakedefine USE_EXTERNAL_ASM
 
 #cmakedefine USE_ENDOMORPHISM
 #cmakedefine USE_EXTERNAL_DEFAULT_CALLBACKS
 
 #cmakedefine USE_ECMULT_STATIC_PRECOMPUTATION
 #define ECMULT_WINDOW_SIZE ${SECP256K1_ECMULT_WINDOW_SIZE}
 #define ECMULT_GEN_PREC_BITS ${SECP256K1_ECMULT_GEN_PRECISION}
 
 #cmakedefine ENABLE_MODULE_ECDH
 #cmakedefine ENABLE_MODULE_MULTISET
 #cmakedefine ENABLE_MODULE_RECOVERY
 #cmakedefine ENABLE_MODULE_SCHNORR
+#cmakedefine ENABLE_MODULE_EXTRAKEYS
+#cmakedefine ENABLE_MODULE_SCHNORRSIG
 
 #cmakedefine ENABLE_OPENSSL_TESTS
 
 #cmakedefine COVERAGE
 
 #endif /* LIBSECP256K1_CONFIG_H */
diff --git a/src/secp256k1/src/modules/schnorrsig/Makefile.am.include b/src/secp256k1/src/modules/schnorrsig/Makefile.am.include
index 0efafa8a1..a82bafe43 100644
--- a/src/secp256k1/src/modules/schnorrsig/Makefile.am.include
+++ b/src/secp256k1/src/modules/schnorrsig/Makefile.am.include
@@ -1,3 +1,8 @@
 include_HEADERS += include/secp256k1_schnorrsig.h
 noinst_HEADERS += src/modules/schnorrsig/main_impl.h
-noinst_HEADERS += src/modules/schnorrsig/tests_impl.h
\ No newline at end of file
+noinst_HEADERS += src/modules/schnorrsig/tests_impl.h
+if USE_BENCHMARK
+noinst_PROGRAMS += bench_schnorrsig
+bench_schnorrsig_SOURCES = src/bench_schnorrsig.c
+bench_schnorrsig_LDADD = libsecp256k1.la $(SECP_LIBS) $(COMMON_LIB)
+endif