Set version to 0.6.2 (#41)

We're now at 0559fc6e41b65af6e52c32eb9b1286494412a162, same as bitcoin core at 98a2ddcd6ed01a38cd0dad7c1abc7023a60d3fd0

.github/workflows/release.yml

@@ -28,6 +28,35 @@ jobs:
           path: ~/.gradle
           key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}-${{ hashFiles('**/gradle/wrapper/gradle-wrapper.properties') }}
           restore-keys: ${{ runner.os }}-gradle-
+      - name: Android environment
+        shell: bash
+        run: |
+          echo "ANDROID_HOME=$ANDROID_HOME" >> $GITHUB_ENV
+          echo "ANDROID_NDK_VERSION=21.4.7075529" >> $GITHUB_ENV
+      - name: Cached Android NDK
+        uses: actions/cache@v2
+        with:
+          path: ${{ format('{0}/ndk/{1}', env.ANDROID_HOME, env.ANDROID_NDK_VERSION) }}
+          key: ${{ runner.os }}-android-ndk-${{ env.ANDROID_NDK_VERSION }}
+      - name: Set up shell
+        if: matrix.os == 'windows-latest'
+        run: |
+          echo "C:\msys64\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          rm.exe "C:/WINDOWS/system32/bash.EXE"
+      - name: Set up JDK 8
+        uses: actions/setup-java@v1
+        with:
+          java-version: 8
+      - name: Setup Android
+        if: matrix.os != 'windows-latest'
+        shell: bash
+        run: |
+          $ANDROID_HOME/tools/bin/sdkmanager "ndk;$ANDROID_NDK_VERSION"
+      - name: Setup Android
+        if: matrix.os == 'windows-latest'
+        shell: bash
+        run: |
+          $ANDROID_HOME\\tools\\bin\\sdkmanager.bat "ndk;$ANDROID_NDK_VERSION"
       - name: Set up JDK 11
         uses: actions/setup-java@v1
         with:
@@ -35,11 +64,6 @@ jobs:
       - name: Install Automake
         if: matrix.os == 'macOS-latest'
         run: brew install automake
-      - name: Set up shell
-        if: matrix.os == 'windows-latest'
-        run: |
-          echo ::add-path::C:\msys64\usr\bin\
-          rm.exe "C:/WINDOWS/system32/bash.EXE"
       - name: Check JVM
         shell: bash
         run: ./gradlew jvmTest
@@ -55,8 +79,10 @@ jobs:
         if: matrix.os == 'macOS-latest'
         uses: reactivecircus/android-emulator-runner@v2
         with:
-          api-level: 29
-          ndk: 21.3.6528147
+          api-level: 27
+          emulator-build: 7425822  # workaround to emulator bug: https://github.com/ReactiveCircus/android-emulator-runner/issues/160
+          emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none
+          ndk: ${{ env.ANDROID_NDK_VERSION }}
           cmake: 3.10.2.4988404
           script: ./gradlew connectedCheck
       - name: Publish Linux
@@ -65,24 +91,38 @@ jobs:
           BINTRAY_USER: ${{ secrets.bintray_user }}
           BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
         shell: bash
-        run: ./gradlew publishLinuxPublicationToBintrayRepository :jni:jvm:linux:publishJvmPublicationToBintrayRepository
+#          ./gradlew publishLinuxPublicationToBintrayRepository :jni:jvm:linux:publishJvmPublicationToBintrayRepository
+        run: ./gradlew publishLinuxPublicationToMavenLocal :jni:jvm:linux:publishJvmPublicationToMavenLocal
       - name: Publish Windows
         if: matrix.os == 'windows-latest'
         env:
           BINTRAY_USER: ${{ secrets.bintray_user }}
           BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
         shell: bash
-        run: ./gradlew :jni:jvm:mingw:publishJvmPublicationToBintrayRepository
+#          ./gradlew :jni:jvm:mingw:publishJvmPublicationToBintrayRepository
+        run: ./gradlew :jni:jvm:mingw:publishToMavenLocal
       - name: Publish MacOS
         if: matrix.os == 'macOS-latest'
         env:
           BINTRAY_USER: ${{ secrets.bintray_user }}
           BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
         shell: bash
-        run: ./gradlew publish
-      - name: Discard
-        if: ${{ failure() || cancelled() }}
-        env:
-          BINTRAY_USER: ${{ secrets.bintray_user }}
-          BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
-        run: ./gradlew postBintrayDiscard
+#          ./gradlew publish
+        run: ./gradlew publishToMavenLocal
+      - name: Copy artifact files
+        run: |
+          mkdir -p maven-local/release
+          cp -r ~/.m2/repository/* maven-local/release
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: release
+          path: |
+            maven-local
+            !maven-local/**/maven-metadata-local.xml
+#      - name: Discard
+#        if: ${{ failure() || cancelled() }}
+#        env:
+#          BINTRAY_USER: ${{ secrets.bintray_user }}
+#          BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
+#        run: ./gradlew postBintrayDiscard

.github/workflows/snapshot.yml

@@ -3,6 +3,7 @@ name: Publish snapshot
 on:
   push:
     branches:
+      - 'master'
       - 'snapshot/*'
     paths-ignore:
       - '**.md'
@@ -36,6 +37,32 @@ jobs:
           path: ~/.gradle
           key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}-${{ hashFiles('**/gradle/wrapper/gradle-wrapper.properties') }}
           restore-keys: ${{ runner.os }}-gradle-
+      - name: Android environment
+        if: matrix.os != 'windows-latest'
+        shell: bash
+        run: |
+          echo "ANDROID_HOME=$ANDROID_HOME" >> $GITHUB_ENV
+          echo "ANDROID_NDK_VERSION=21.4.7075529" >> $GITHUB_ENV
+      - name: Cached Android NDK
+        if: matrix.os != 'windows-latest'
+        uses: actions/cache@v2
+        with:
+          path: ${{ format('{0}/ndk/{1}', env.ANDROID_HOME, env.ANDROID_NDK_VERSION) }}
+          key: ${{ runner.os }}-android-ndk-${{ env.ANDROID_NDK_VERSION }}
+      - name: Set up shell
+        if: matrix.os == 'windows-latest'
+        run: |
+          echo "C:\msys64\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          rm.exe "C:/WINDOWS/system32/bash.EXE"
+      - name: Set up JDK 8
+        uses: actions/setup-java@v1
+        with:
+          java-version: 8
+      - name: Setup Android
+        if: matrix.os != 'windows-latest'
+        shell: bash
+        run: |
+          $ANDROID_HOME/tools/bin/sdkmanager "ndk;$ANDROID_NDK_VERSION"
       - name: Set up JDK 11
         uses: actions/setup-java@v1
         with:
@@ -43,11 +70,6 @@ jobs:
       - name: Install Automake
         if: matrix.os == 'macOS-latest'
         run: brew install automake
-      - name: Set up shell
-        if: matrix.os == 'windows-latest'
-        run: |
-          echo ::add-path::C:\msys64\usr\bin\
-          rm.exe "C:/WINDOWS/system32/bash.EXE"
       - name: Check JVM
         shell: bash
         run: ./gradlew jvmTest
@@ -63,59 +85,33 @@ jobs:
         if: matrix.os == 'macOS-latest'
         uses: reactivecircus/android-emulator-runner@v2
         with:
-          api-level: 29
-          ndk: 21.3.6528147
+          api-level: 27
+          -build: 7425822  # workaround to emulator bug: https://github.com/ReactiveCircus/android-emulator-runner/issues/160
+          emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none
+          ndk: ${{ env.ANDROID_NDK_VERSION }}
           cmake: 3.10.2.4988404
           script: ./gradlew connectedCheck
       - name: Publish Linux
         if: matrix.os == 'ubuntu-latest'
-        env:
-          BINTRAY_USER: ${{ secrets.bintray_user }}
-          BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
         shell: bash
-        run: ./gradlew publishLinuxPublicationToBintrayRepository :jni:jvm:linux:publishJvmPublicationToBintrayRepository -PsnapshotNumber=${{ github.run_number }} -PgitRef=${{ github.ref }}
+        run: ./gradlew publishLinuxPublicationToMavenLocal :jni:jvm:linux:publishJvmPublicationToMavenLocal -PsnapshotNumber=${{ github.run_number }} -PgitRef=${{ github.ref }}
       - name: Publish Windows
         if: matrix.os == 'windows-latest'
-        env:
-          BINTRAY_USER: ${{ secrets.bintray_user }}
-          BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
         shell: bash
-        run: ./gradlew :jni:jvm:mingw:publishJvmPublicationToBintrayRepository -PsnapshotNumber=${{ github.run_number }} -PgitRef=${{ github.ref }}
+        run: ./gradlew :jni:jvm:mingw:publishToMavenLocal -PsnapshotNumber=${{ github.run_number }} -PgitRef=${{ github.ref }}
       - name: Publish MacOS
         if: matrix.os == 'macOS-latest'
-        env:
-          BINTRAY_USER: ${{ secrets.bintray_user }}
-          BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
         shell: bash
-        run: ./gradlew publish -PsnapshotNumber=${{ github.run_number }} -PgitRef=${{ github.ref }}
-      - name: Discard
-        if: ${{ failure() || cancelled() }}
-        env:
-          BINTRAY_USER: ${{ secrets.bintray_user }}
-          BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
-        run: ./gradlew postBintrayDiscard -PsnapshotNumber=${{ github.run_number }} -PgitRef=${{ github.ref }}
+        run: ./gradlew publishToMavenLocal -PsnapshotNumber=${{ github.run_number }} -PgitRef=${{ github.ref }}
+      - name: Copy artifact files
+        run: |
+          mkdir -p maven-local/snapshot
+          cp -r ~/.m2/repository/* maven-local/snapshot
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: snapshot
+          path: |
+            maven-local
+            !maven-local/**/maven-metadata-local.xml
 
-  publish:
-    name: Publish
-    needs: upload
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out
-        uses: actions/checkout@v2
-        with:
-          submodules: 'true'
-      - name: Cached Gradle
-        uses: actions/cache@v2
-        with:
-          path: ~/.gradle
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}-${{ hashFiles('**/gradle/wrapper/gradle-wrapper.properties') }}
-          restore-keys: ${{ runner.os }}-gradle-
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-      - name: Publish
-        env:
-          BINTRAY_USER: ${{ secrets.bintray_user }}
-          BINTRAY_APIKEY: ${{ secrets.bintray_apikey }}
-        run: ./gradlew postBintrayPublish -PsnapshotNumber=${{ github.run_number }} -PgitRef=${{ github.ref }}

.github/workflows/test.yml

@@ -10,7 +10,8 @@ on:
       - '!.github/workflows/test.yml'
   push:
     branches:
-      - 'master'
+      - '!master'
+      - '!snapshot/*'
     paths-ignore:
       - '**.md'
       - '**.adoc'
@@ -42,6 +43,35 @@ jobs:
           path: ~/.gradle
           key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}-${{ hashFiles('**/gradle/wrapper/gradle-wrapper.properties') }}
           restore-keys: ${{ runner.os }}-gradle-
+      - name: Android environment
+        shell: bash
+        run: |
+          echo "ANDROID_HOME=$ANDROID_HOME" >> $GITHUB_ENV
+          echo "ANDROID_NDK_VERSION=21.4.7075529" >> $GITHUB_ENV
+      - name: Cached Android NDK
+        uses: actions/cache@v2
+        with:
+          path: ${{ format('{0}/ndk/{1}', env.ANDROID_HOME, env.ANDROID_NDK_VERSION) }}
+          key: ${{ runner.os }}-android-ndk-${{ env.ANDROID_NDK_VERSION }}
+      - name: Set up shell
+        if: matrix.os == 'windows-latest'
+        run: |
+          echo "C:\msys64\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          rm.exe "C:/WINDOWS/system32/bash.EXE"
+      - name: Set up JDK 8
+        uses: actions/setup-java@v1
+        with:
+          java-version: 8
+      - name: Setup Android
+        if: matrix.os != 'windows-latest'
+        shell: bash
+        run: |
+          $ANDROID_HOME/tools/bin/sdkmanager "ndk;$ANDROID_NDK_VERSION"
+      - name: Setup Android
+        if: matrix.os == 'windows-latest'
+        shell: bash
+        run: |
+          $ANDROID_HOME\\tools\\bin\\sdkmanager.bat "ndk;$ANDROID_NDK_VERSION"
       - name: Set up JDK 11
         uses: actions/setup-java@v1
         with:
@@ -49,11 +79,6 @@ jobs:
       - name: Install Automake
         if: matrix.os == 'macOS-latest'
         run: brew install automake
-      - name: Set up shell
-        if: matrix.os == 'windows-latest'
-        run: |
-          echo ::add-path::C:\msys64\usr\bin\
-          rm.exe "C:/WINDOWS/system32/bash.EXE"
       - name: Check JVM
         shell: bash
         run: ./gradlew jvmTest
@@ -69,7 +94,9 @@ jobs:
         if: matrix.os == 'macOS-latest'
         uses: reactivecircus/android-emulator-runner@v2
         with:
-          api-level: 29
-          ndk: 21.3.6528147
+          api-level: 27
+          emulator-build: 7425822  # workaround to emulator bug: https://github.com/ReactiveCircus/android-emulator-runner/issues/160
+          emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none
+          ndk: ${{ env.ANDROID_NDK_VERSION }}
           cmake: 3.10.2.4988404
           script: ./gradlew connectedCheck

README.md

@@ -1,19 +1,15 @@
+[![Kotlin](https://img.shields.io/badge/Kotlin-1.5.31-blue.svg?style=flat&logo=kotlin)](http://kotlinlang.org)
+[![Maven Central](https://img.shields.io/maven-central/v/fr.acinq.secp256k1/secp256k1-kmp)](https://search.maven.org/search?q=g:fr.acinq.secp256k1%20a:secp256k1-kmp*)
+![Github Actions](https://github.com/ACINQ/secp256k1-kmp/actions/workflows/test.yml/badge.svg)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ACINQ/secp256k1-kmp/blob/master/LICENSE)
+
 # Secp256k1 for Kotlin/Multiplatform
 
 Kotlin/Multiplatform wrapper for Bitcoin Core's secp256k1 library. Targets: JVM, Android, iOS & Linux.
 
 ## Installation
 
-[ ![Download](https://api.bintray.com/packages/acinq/libs/secp256k1/images/download.svg) ](https://bintray.com/acinq/libs/secp256k1-kmp/)
-
-First, you need to add the ACINQ libraries repository:
-
-```kotlin
-// build.gradle.kts
-repositories {
-    maven(url = "https://dl.bintray.com/acinq/libs")
-}
-```
+secp256k1-kmp is available on [maven central](https://search.maven.org/search?q=g:fr.acinq.secp256k1%20a:secp256k1-kmp*)
 
 Then, the actual dependency depends on your targeted platform(s):
 
@@ -88,3 +84,58 @@ You can also specify the temporary directory where the library will be extracted
 ## Usage
 
 Please have a look at unit tests, more samples will be added soon.
+
+## Building
+
+**secp256k1-kmp** is a [Kotlin Multiplatform](https://kotlinlang.org/docs/multiplatform.html) wrapper for Bitcoin Core's [secp256k1 library](https://github.com/bitcoin-core/secp256k1).
+
+To build the library you need the following:
+- Window 64 bits, Linux 64 bits, or MacOs 64 Bits
+- OpenJDK11 (we recommend using packages provided by https://adoptopenjdk.net/ but there are other options)
+- (optional) Android SDK
+
+It may work with other Operating Systems and JDKs, but then you're on your own (in particular we don't plan to support 32 bits Operating Systems).
+To build the library and publish compiled artefacts locally (so they can be used by other projects):
+
+```sh
+./gradlew :build
+./gradlew :publishToMavenLocal
+```
+
+To run all tests on all platforms:
+
+```sh
+./gradlew allTests
+```
+
+To run tests on a single platform, for example the JVM:
+
+```sh
+./gradlew jvmTest
+```
+
+If you want to skip building Android artefacts create a `local.properties` file in the project's root directory and add the following line:
+
+```
+skip.android=true
+```
+
+## Contributing to and extending the library
+
+secp256k1-kmp follows 2 simples rules:
+- copy as literally as possible what the original [secp256k1 library](https://github.com/bitcoin-core/secp256k1) does: use the same function names, parameters, options, ... 
+- follow JNI best practices (memory allocation, error handling, ...)
+ 
+"Porting" C/C++ code that uses [secp256k1](https://github.com/bitcoin-core/secp256k1) should be a no-brainer and we should not have to document secp256k1-kmp
+
+
+To extend this library and support methods that have been added to specific versions of [secp256k1](https://github.com/bitcoin-core/secp256k1) you have to:
+- add new methods to the Secp256k1 interface src/commonMain/kotlin/fr/acinq/secp256k1/Secp256k1.kt (please follow rule #1 above and try and match secp256k1's interface as much as possible)
+- implement these new methods in jni/src/main/kotlin/fr/acinq/secp256k1/NativeSecp256k1.kt (JNI implementation) and src/nativeMain/kotlin/fr/acinq/secp256k1/Secp256k1Native.kt (native linux/ios/... implementation)
+- update the JNI interface src/main/java/fr/acinq/secp256k1/Secp256k1CFunctions.java (NativeSecp256k1 calls Secp256k1CFunctions)
+- generate a new JNI header file jni/c/headers/java/fr_acinq_secp256k1_Secp256k1CFunctions.h with `javac -h jni/c/headers/java jni/src/main/java/fr/acinq/secp256k1/Secp256k1CFunctions.java`
+- implement the new methods in jni/c/src/fr_acinq_secp256k1_Secp256k1CFunctions.c
+
+You may also need to modify build files if you need to compile [secp256k1](https://github.com/bitcoin-core/secp256k1) with custom options
+
+We use [secp256k1](https://github.com/bitcoin-core/secp256k1) through git submodules so you may also need to change what they point to

build.gradle.kts

@@ -1,35 +1,32 @@
-import org.apache.http.impl.client.HttpClients
-import org.apache.http.client.methods.HttpPost
-import org.apache.http.entity.ContentType
-import org.apache.http.entity.StringEntity
-import org.apache.http.impl.auth.BasicScheme
-import org.apache.http.auth.UsernamePasswordCredentials
 import org.gradle.internal.os.OperatingSystem
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import org.jetbrains.dokka.Platform
 
 plugins {
-    kotlin("multiplatform") version "1.4.0"
+    kotlin("multiplatform") version "1.5.31"
+    id("org.jetbrains.dokka") version "1.5.30"
     `maven-publish`
 }
 
 buildscript {
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
 
     dependencies {
-        classpath("com.android.tools.build:gradle:4.0.1")
+        classpath("com.android.tools.build:gradle:4.0.2")
+        classpath("org.jetbrains.dokka:dokka-gradle-plugin:1.5.30")
     }
 }
 
 allprojects {
     group = "fr.acinq.secp256k1"
-    version = "0.3.0"
+    version = "0.6.2"
 
     repositories {
-        jcenter()
         google()
+        mavenCentral()
     }
 }
 
@@ -66,7 +63,6 @@ kotlin {
 
     ios {
         secp256k1CInterop("ios")
-        // https://youtrack.jetbrains.com/issue/KT-39396
         compilations["main"].defaultSourceSet.dependsOn(nativeMain)
         // https://youtrack.jetbrains.com/issue/KT-39396
         compilations["main"].kotlinOptions.freeCompilerArgs += listOf("-include-binary", "$rootDir/native/build/ios/libsecp256k1.a")
@@ -75,7 +71,6 @@ kotlin {
     sourceSets.all {
         languageSettings.useExperimentalAnnotation("kotlin.RequiresOptIn")
     }
-
 }
 
 // Disable cross compilation
@@ -108,41 +103,27 @@ allprojects {
     }
 }
 
-val snapshotNumber: String? by project
-val gitRef: String? by project
-val eapBranch = gitRef?.split("/")?.last() ?: "dev"
-val bintrayVersion = if (snapshotNumber != null) "${project.version}-$eapBranch-$snapshotNumber" else project.version.toString()
-val bintrayRepo = if (snapshotNumber != null) "snapshots" else "libs"
-
-val bintrayUsername: String? = (properties["bintrayUsername"] as String?) ?: System.getenv("BINTRAY_USER")
-val bintrayApiKey: String? = (properties["bintrayApiKey"] as String?) ?: System.getenv("BINTRAY_APIKEY")
-val hasBintray = bintrayUsername != null && bintrayApiKey != null
-if (!hasBintray) logger.warn("Skipping bintray configuration as bintrayUsername or bintrayApiKey is not defined")
-
 allprojects {
+    val javadocJar = tasks.create<Jar>("javadocJar") {
+        archiveClassifier.set("javadoc")
+        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    }
+
+    // Publication
     plugins.withId("maven-publish") {
         publishing {
-            if (hasBintray) {
-                repositories {
-                    maven {
-                        name = "bintray"
-                        setUrl("https://api.bintray.com/maven/acinq/$bintrayRepo/${rootProject.name}/;publish=0")
-                        credentials {
-                            username = bintrayUsername
-                            password = bintrayApiKey
-                        }
-                    }
-                }
-            }
-
             publications.withType<MavenPublication>().configureEach {
-                version = bintrayVersion
+                version = project.version.toString()
+                artifact(javadocJar)
                 pom {
+                    name.set("secp256k1 for Kotlin/Multiplatform")
                     description.set("Bitcoin's secp256k1 library ported to Kotlin/Multiplatform for JVM, Android, iOS & Linux")
                     url.set("https://github.com/ACINQ/secp256k1-kmp")
                     licenses {
-                        name.set("Apache License v2.0")
-                        url.set("https://www.apache.org/licenses/LICENSE-2.0")
+                        license {
+                            name.set("Apache License v2.0")
+                            url.set("https://www.apache.org/licenses/LICENSE-2.0")
+                        }
                     }
                     issueManagement {
                         system.set("Github")
@@ -150,35 +131,49 @@ allprojects {
                     }
                     scm {
                         connection.set("https://github.com/ACINQ/secp256k1-kmp.git")
+                        url.set("https://github.com/ACINQ/secp256k1-kmp")
+                    }
+                    developers {
+                        developer {
+                            name.set("ACINQ")
+                            email.set("hello@acinq.co")
+                        }
                     }
                 }
             }
         }
     }
-}
 
-if (hasBintray) {
-    val postBintrayPublish by tasks.creating {
-        doLast {
-            HttpClients.createDefault().use { client ->
-                val post = HttpPost("https://api.bintray.com/content/acinq/$bintrayRepo/${rootProject.name}/$bintrayVersion/publish").apply {
-                    entity = StringEntity("{}", ContentType.APPLICATION_JSON)
-                    addHeader(BasicScheme().authenticate(UsernamePasswordCredentials(bintrayUsername, bintrayApiKey), this, null))
-                }
-                client.execute(post)
-            }
-        }
-    }
+    if (project.name !in listOf("native", "tests")) {
+        afterEvaluate {
+            val dokkaOutputDir = buildDir.resolve("dokka")
 
-    val postBintrayDiscard by tasks.creating {
-        doLast {
-            HttpClients.createDefault().use { client ->
-                val post = HttpPost("https://api.bintray.com/content/acinq/$bintrayRepo/${rootProject.name}/$bintrayVersion/publish").apply {
-                    entity = StringEntity("{ \"discard\": true }", ContentType.APPLICATION_JSON)
-                    addHeader(BasicScheme().authenticate(UsernamePasswordCredentials(bintrayUsername, bintrayApiKey), this, null))
+            tasks.dokkaHtml {
+                outputDirectory.set(file(dokkaOutputDir))
+                dokkaSourceSets {
+                    configureEach {
+                        val platformName = when (platform.get()) {
+                            Platform.jvm -> "jvm"
+                            Platform.js -> "js"
+                            Platform.native -> "native"
+                            Platform.common -> "common"
+                        }
+                        displayName.set(platformName)
+
+                        perPackageOption {
+                            matchingRegex.set(".*\\.internal.*") // will match all .internal packages and sub-packages
+                            suppress.set(true)
+                        }
+                    }
                 }
-                client.execute(post)
             }
+
+            val deleteDokkaOutputDir by tasks.register<Delete>("deleteDokkaOutputDirectory") {
+                delete(dokkaOutputDir)
+            }
+
+            javadocJar.dependsOn(deleteDokkaOutputDir, tasks.dokkaHtml)
+            javadocJar.from(dokkaOutputDir)
         }
     }
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

jni/android/build.gradle.kts

@@ -1,6 +1,9 @@
+import org.jetbrains.dokka.Platform
+
 plugins {
     id("com.android.library")
     kotlin("android")
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
@@ -32,7 +35,7 @@ android {
             setPath("src/main/CMakeLists.txt")
         }
     }
-    ndkVersion = "21.3.6528147"
+    ndkVersion = "21.4.7075529"
 
     afterEvaluate {
         tasks.withType<com.android.build.gradle.tasks.factory.AndroidUnitTest>().all {
@@ -51,8 +54,13 @@ afterEvaluate {
     publishing {
         publications {
             create<MavenPublication>("android") {
-                artifactId = "secp256k1-jni-android"
+                artifactId = "secp256k1-kmp-jni-android"
                 from(components["release"])
+                val sourcesJar = task<Jar>("sourcesJar") {
+                    archiveClassifier.set("sources")
+                    from(android.sourceSets["main"].java.srcDirs)
+                }
+                artifact(sourcesJar)
             }
         }
     }

jni/build.gradle.kts

@@ -1,5 +1,8 @@
+import org.jetbrains.dokka.Platform
+
 plugins {
     kotlin("jvm")
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
@@ -34,8 +37,13 @@ val generateHeaders by tasks.creating(JavaCompile::class) {
 publishing {
     publications {
         create<MavenPublication>("jvm") {
-            artifactId = "secp256k1-jni-common"
+            artifactId = "secp256k1-kmp-jni-common"
             from(components["java"])
+            val sourcesJar = task<Jar>("sourcesJar") {
+                archiveClassifier.set("sources")
+                from(sourceSets["main"].allSource)
+            }
+            artifact(sourcesJar)
         }
     }
 }

jni/c/headers/java/fr_acinq_secp256k1_Secp256k1CFunctions.h

@@ -119,14 +119,6 @@ JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256
 JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1ec_1pubkey_1tweak_1mul
   (JNIEnv *, jclass, jlong, jbyteArray, jbyteArray);
 
-/*
- * Class:     fr_acinq_secp256k1_Secp256k1CFunctions
- * Method:    secp256k1_ec_pubkey_add
- * Signature: (J[B[B)[B
- */
-JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1ec_1pubkey_1add
-  (JNIEnv *, jclass, jlong, jbyteArray, jbyteArray);
-
 /*
  * Class:     fr_acinq_secp256k1_Secp256k1CFunctions
  * Method:    secp256k1_ec_pubkey_combine
@@ -159,6 +151,22 @@ JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256
 JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1compact_1to_1der
   (JNIEnv *, jclass, jlong, jbyteArray);
 
+/*
+ * Class:     fr_acinq_secp256k1_Secp256k1CFunctions
+ * Method:    secp256k1_schnorrsig_sign
+ * Signature: (J[B[B[B)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1schnorrsig_1sign
+  (JNIEnv *, jclass, jlong, jbyteArray, jbyteArray, jbyteArray);
+
+/*
+ * Class:     fr_acinq_secp256k1_Secp256k1CFunctions
+ * Method:    secp256k1_schnorrsig_verify
+ * Signature: (J[B[B[B)I
+ */
+JNIEXPORT jint JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1schnorrsig_1verify
+  (JNIEnv *, jclass, jlong, jbyteArray, jbyteArray, jbyteArray);
+
 #ifdef __cplusplus
 }
 #endif

jni/c/src/fr_acinq_secp256k1_Secp256k1CFunctions.c

@@ -4,6 +4,7 @@
 #include "include/secp256k1.h"
 #include "include/secp256k1_ecdh.h"
 #include "include/secp256k1_recovery.h"
+#include "include/secp256k1_schnorrsig.h"
 #include "fr_acinq_secp256k1_Secp256k1CFunctions.h"
 
 #define SIG_FORMAT_UNKNOWN 0
@@ -72,7 +73,8 @@ JNIEXPORT jint JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1ec
 
     if (jctx == 0) return 0;
     if (jseckey == NULL) return 0;
-    CHECKRESULT((*penv)->GetArrayLength(penv, jseckey) != 32, "secret key must be 32 bytes");
+    if ((*penv)->GetArrayLength(penv, jseckey) != 32) return 0;
+
     seckey = (*penv)->GetByteArrayElements(penv, jseckey, 0);
     result = secp256k1_ec_seckey_verify(ctx, (unsigned char*)seckey);
     (*penv)->ReleaseByteArrayElements(penv, jseckey, seckey, 0);
@@ -133,11 +135,8 @@ JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256
 
     CHECKRESULT((*penv)->GetArrayLength(penv, jseckey) != 32, "secret key must be 32 bytes");
     seckey = (*penv)->GetByteArrayElements(penv, jseckey, 0);
-    jpubkey = (*penv)->NewByteArray(penv, 65);
-    pubkey = (*penv)->GetByteArrayElements(penv, jpubkey, 0);
     result = secp256k1_ec_pubkey_create(ctx, &pub, (unsigned char*)seckey);
     (*penv)->ReleaseByteArrayElements(penv, jseckey, seckey, 0);
-    (*penv)->ReleaseByteArrayElements(penv, jpubkey, pubkey, 0);
     CHECKRESULT(!result, "secp256k1_ec_pubkey_create failed");
     jpubkey = (*penv)->NewByteArray(penv, 65);
     pubkey = (*penv)->GetByteArrayElements(penv, jpubkey, 0);
@@ -494,51 +493,6 @@ void free_pubkeys(secp256k1_pubkey **pubkeys, size_t count)
     free(pubkeys);
 }
 
-/*
- * Class:     fr_acinq_bitcoin_Secp256k1Bindings
- * Method:    secp256k1_ec_pubkey_add
- * Signature: (J[B[B)[B
- */
-JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1ec_1pubkey_1add
-  (JNIEnv *penv, jclass clazz, jlong jctx, jbyteArray jpubkey1, jbyteArray jpubkey2)
-{
-    secp256k1_context* ctx = (secp256k1_context *)jctx;
-    jbyte *pub1, *pub2;
-    secp256k1_pubkey pubkey1, pubkey2, combined;
-    secp256k1_pubkey const *pubkeys[2] = { &pubkey1, &pubkey2 };
-    size_t size = 0;
-    int result = 0;
-
-    if (jctx == 0) return NULL;
-    if (jpubkey1 == NULL) return NULL;
-    if (jpubkey2 == NULL) return NULL;
-
-    size = (*penv)->GetArrayLength(penv, jpubkey1);
-    CHECKRESULT((size != 33) && (size != 65), "invalid public key size");
-    pub1 = (*penv)->GetByteArrayElements(penv, jpubkey1, 0);
-    result = secp256k1_ec_pubkey_parse(ctx, &pubkey1, (unsigned char*)pub1, size);
-    (*penv)->ReleaseByteArrayElements(penv, jpubkey1, pub1, 0);
-    CHECKRESULT(!result, "secp256k1_ec_pubkey_parse failed");
-
-    size = (*penv)->GetArrayLength(penv, jpubkey2);
-    CHECKRESULT((size != 33) && (size != 65), "invalid public key size");
-    pub2 = (*penv)->GetByteArrayElements(penv, jpubkey2, 0);
-    result = secp256k1_ec_pubkey_parse(ctx, &pubkey2, (unsigned char*)pub2, size);
-    (*penv)->ReleaseByteArrayElements(penv, jpubkey2, pub2, 0);
-    CHECKRESULT(!result, "secp256k1_ec_pubkey_parse failed");
-
-    result = secp256k1_ec_pubkey_combine(ctx, &combined, pubkeys, 2);
-    CHECKRESULT(!result, "secp256k1_ec_pubkey_combine failed");
-
-    size = 65;
-    jpubkey1 = (*penv)->NewByteArray(penv, 65);
-    pub1 = (*penv)->GetByteArrayElements(penv, jpubkey1, 0);
-    result = secp256k1_ec_pubkey_serialize(ctx, (unsigned char*)pub1, &size, &combined, SECP256K1_EC_UNCOMPRESSED);
-    (*penv)->ReleaseByteArrayElements(penv, jpubkey1, pub1, 0);
-    CHECKRESULT(!result, "secp256k1_ec_pubkey_serialize failed");
-    return jpubkey1;
-}
-
 /*
  * Class:     fr_acinq_bitcoin_Secp256k1Bindings
  * Method:    secp256k1_ec_pubkey_combine
@@ -713,3 +667,86 @@ JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256
     (*penv)->ReleaseByteArrayElements(penv, jsig, sig, 0);
     return jsig;
 }
+
+/*
+ * Class:     fr_acinq_secp256k1_Secp256k1CFunctions
+ * Method:    secp256k1_schnorrsig_sign
+ * Signature: (J[B[B[B)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1schnorrsig_1sign
+  (JNIEnv *penv, jclass clazz, jlong jctx, jbyteArray jmsg, jbyteArray jseckey, jbyteArray jauxrand32)
+{
+    secp256k1_context* ctx = (secp256k1_context *)jctx;
+    jbyte *seckey, *msg, *sig, *auxrand32 = NULL;
+    secp256k1_keypair keypair;
+    unsigned char signature[64];
+    int result = 0;
+    jbyteArray jsig;
+
+    if (jctx == 0) return NULL;
+    if (jmsg == NULL) return NULL;
+    if (jseckey == NULL) return NULL;
+
+    CHECKRESULT((*penv)->GetArrayLength(penv, jseckey) != 32, "secret key must be 32 bytes");
+    CHECKRESULT((*penv)->GetArrayLength(penv, jmsg) != 32, "message must be 32 bytes");
+    if (jauxrand32 != 0) {
+        CHECKRESULT((*penv)->GetArrayLength(penv, jauxrand32) != 32, "auxiliary random data must be 32 bytes");
+    }
+    seckey = (*penv)->GetByteArrayElements(penv, jseckey, 0);
+    result = secp256k1_keypair_create(ctx, &keypair, seckey);
+    (*penv)->ReleaseByteArrayElements(penv, jseckey, seckey, 0);
+    CHECKRESULT(!result, "secp256k1_keypair_create failed");
+
+    msg = (*penv)->GetByteArrayElements(penv, jmsg, 0);
+    if (jauxrand32 != 0) {
+        auxrand32 = (*penv)->GetByteArrayElements(penv, jauxrand32, 0);
+    }
+
+    result = secp256k1_schnorrsig_sign(ctx, signature, (unsigned char*)msg, &keypair, auxrand32);
+    (*penv)->ReleaseByteArrayElements(penv, jmsg, msg, 0);
+    if (auxrand32 != 0) {
+        (*penv)->ReleaseByteArrayElements(penv, jauxrand32, auxrand32, 0);
+    }
+    CHECKRESULT(!result, "secp256k1_schnorrsig_sign failed");
+
+    jsig = (*penv)->NewByteArray(penv, 64);
+    sig = (*penv)->GetByteArrayElements(penv, jsig, 0);
+    memcpy(sig, signature, 64);
+    (*penv)->ReleaseByteArrayElements(penv, jsig, sig, 0);
+    return jsig;
+}
+
+/*
+ * Class:     fr_acinq_secp256k1_Secp256k1CFunctions
+ * Method:    secp256k1_schnorrsig_verify
+ * Signature: (J[B[B[B)I
+ */
+JNIEXPORT jint JNICALL Java_fr_acinq_secp256k1_Secp256k1CFunctions_secp256k1_1schnorrsig_1verify
+  (JNIEnv *penv, jclass clazz, jlong jctx, jbyteArray jsig, jbyteArray jmsg, jbyteArray jpubkey)
+{
+    secp256k1_context* ctx = (secp256k1_context *)jctx;
+    jbyte *pub, *msg, *sig;
+    secp256k1_xonly_pubkey pubkey;
+    int result = 0;
+
+    if (jctx == 0) return 0;
+    if (jsig == NULL) return 0;
+    if (jmsg == NULL) return 0;
+    if (jpubkey == NULL) return 0;
+
+    CHECKRESULT((*penv)->GetArrayLength(penv, jsig) != 64, "signature must be 64 bytes");
+    CHECKRESULT((*penv)->GetArrayLength(penv, jpubkey) != 32, "public key must be 32 bytes");
+    CHECKRESULT((*penv)->GetArrayLength(penv, jmsg) != 32, "message must be 32 bytes");
+
+    pub = (*penv)->GetByteArrayElements(penv, jpubkey, 0);
+    result = secp256k1_xonly_pubkey_parse(ctx, &pubkey, (unsigned char*)pub);
+    (*penv)->ReleaseByteArrayElements(penv, jpubkey, pub, 0);
+    CHECKRESULT(!result, "secp256k1_ec_pubkey_parse failed");
+
+    sig = (*penv)->GetByteArrayElements(penv, jsig, 0);
+    msg = (*penv)->GetByteArrayElements(penv, jmsg, 0);
+    result = secp256k1_schnorrsig_verify(ctx, (unsigned char*)sig, (unsigned char*)msg, 32, &pubkey);
+    (*penv)->ReleaseByteArrayElements(penv, jsig, sig, 0);
+    (*penv)->ReleaseByteArrayElements(penv, jmsg, msg, 0);
+    return result;
+}

jni/jvm/all/build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
     `java-library`
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
@@ -12,8 +13,12 @@ dependencies {
 publishing {
     publications {
         create<MavenPublication>("jvm") {
-            artifactId = "secp256k1-jni-jvm"
+            artifactId = "secp256k1-kmp-jni-jvm"
             from(components["java"])
+            val sourcesJar = task<Jar>("sourcesJar") {
+                archiveClassifier.set("sources")
+            }
+            artifact(sourcesJar)
         }
     }
 }

jni/jvm/build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
     kotlin("jvm")
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
@@ -33,8 +34,12 @@ dependencies {
 publishing {
     publications {
         create<MavenPublication>("jvm") {
-            artifactId = "secp256k1-jni-jvm-extract"
+            artifactId = "secp256k1-kmp-jni-jvm-extract"
             from(components["java"])
+            val sourcesJar = task<Jar>("sourcesJar") {
+                archiveClassifier.set("sources")
+            }
+            artifact(sourcesJar)
         }
     }
 }

jni/jvm/build.sh

@@ -14,11 +14,9 @@ JNI_HEADERS=$TARGET
 
 if [ "$TARGET" == "linux" ]; then
   OUTFILE=libsecp256k1-jni.so
-  ADD_LIB=-lgmp
   CC_OPTS="-fPIC"
 elif [ "$TARGET" == "darwin" ]; then
   OUTFILE=libsecp256k1-jni.dylib
-  ADD_LIB=-lgmp
 elif [ "$TARGET" == "mingw" ]; then
   OUTFILE=secp256k1-jni.dll
   CC=x86_64-w64-mingw32-gcc

jni/jvm/darwin/build.gradle.kts

@@ -1,5 +1,7 @@
 plugins {
     kotlin("jvm")
+    `java-library`
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
@@ -23,8 +25,12 @@ val copyJni by tasks.creating(Sync::class) {
 publishing {
     publications {
         val pub = create<MavenPublication>("jvm") {
-            artifactId = "secp256k1-jni-jvm-darwin"
+            artifactId = "secp256k1-kmp-jni-jvm-darwin"
             from(components["java"])
+            val sourcesJar = task<Jar>("sourcesJar") {
+                archiveClassifier.set("sources")
+            }
+            artifact(sourcesJar)
         }
         if (!org.gradle.internal.os.OperatingSystem.current().isMacOsX) {
             tasks.withType<AbstractPublishToMaven>().all { onlyIf { publication != pub } }

jni/jvm/linux/build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
     kotlin("jvm")
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
@@ -23,8 +24,12 @@ val copyJni by tasks.creating(Sync::class) {
 publishing {
     publications {
         val pub = create<MavenPublication>("jvm") {
-            artifactId = "secp256k1-jni-jvm-linux"
+            artifactId = "secp256k1-kmp-jni-jvm-linux"
             from(components["java"])
+            val sourcesJar = task<Jar>("sourcesJar") {
+                archiveClassifier.set("sources")
+            }
+            artifact(sourcesJar)
         }
         if (!org.gradle.internal.os.OperatingSystem.current().isLinux) {
             tasks.withType<AbstractPublishToMaven>().all { onlyIf { publication != pub } }

jni/jvm/mingw/build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
     kotlin("jvm")
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
@@ -23,8 +24,12 @@ val copyJni by tasks.creating(Sync::class) {
 publishing {
     publications {
         val pub = create<MavenPublication>("jvm") {
-            artifactId = "secp256k1-jni-jvm-mingw"
+            artifactId = "secp256k1-kmp-jni-jvm-mingw"
             from(components["java"])
+            val sourcesJar = task<Jar>("sourcesJar") {
+                archiveClassifier.set("sources")
+            }
+            artifact(sourcesJar)
         }
         if (!org.gradle.internal.os.OperatingSystem.current().isWindows) {
             tasks.withType<AbstractPublishToMaven>().all { onlyIf { publication != pub } }

jni/jvm/src/main/kotlin/fr/acinq/secp256k1/jni/OSInfo.kt

@@ -154,7 +154,7 @@ internal object OSInfo {
                if (systemOsArch.startsWith("arm")) {
                    resolveArmArchType()
                } else {
-                   val lc = systemOsArch.toLowerCase(Locale.US)
+                   val lc = systemOsArch.lowercase(Locale.US)
                    if (archMapping.containsKey(lc)) return archMapping[lc]
                    systemOsArch
                }

jni/src/main/java/fr/acinq/secp256k1/Secp256k1CFunctions.java

@@ -57,8 +57,6 @@ public class Secp256k1CFunctions {
 
     public static native byte[] secp256k1_ec_pubkey_tweak_mul(long ctx, byte[] pubkey, byte[] tweak);
 
-    public static native byte[] secp256k1_ec_pubkey_add(long ctx, byte[] pubkey1, byte[] pubkey2);
-
     public static native byte[] secp256k1_ec_pubkey_combine(long ctx, byte[][] pubkeys);
 
     public static native byte[] secp256k1_ecdh(long ctx, byte[] seckey, byte[] pubkey);
@@ -66,4 +64,8 @@ public class Secp256k1CFunctions {
     public static native byte[] secp256k1_ecdsa_recover(long ctx, byte[] sig, byte[] msg32, int recid);
 
     public static native byte[] secp256k1_compact_to_der(long ctx, byte[] sig);
+
+    public static native byte[] secp256k1_schnorrsig_sign(long ctx, byte[] msg, byte[] seckey, byte[] aux_rand32);
+
+    public static native int secp256k1_schnorrsig_verify(long ctx, byte[] sig, byte[] msg, byte[] pubkey);
 }

jni/src/main/kotlin/fr/acinq/secp256k1/NativeSecp256k1.kt

@@ -14,15 +14,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package fr.acinq.secp256k1
 
 public object NativeSecp256k1 : Secp256k1 {
-    override fun verify(signature: ByteArray, data: ByteArray, pub: ByteArray): Boolean {
-        return Secp256k1CFunctions.secp256k1_ecdsa_verify(Secp256k1Context.getContext(), signature, data, pub) == 1
+    override fun verify(signature: ByteArray, message: ByteArray, pubkey: ByteArray): Boolean {
+        return Secp256k1CFunctions.secp256k1_ecdsa_verify(Secp256k1Context.getContext(), signature, message, pubkey) == 1
     }
 
-    override fun sign(data: ByteArray, sec: ByteArray): ByteArray {
-        return Secp256k1CFunctions.secp256k1_ecdsa_sign(Secp256k1Context.getContext(), data, sec)
+    override fun sign(message: ByteArray, privkey: ByteArray): ByteArray {
+        return Secp256k1CFunctions.secp256k1_ecdsa_sign(Secp256k1Context.getContext(), message, privkey)
     }
 
     override fun signatureNormalize(sig: ByteArray): Pair<ByteArray, Boolean> {
@@ -31,35 +32,30 @@ public object NativeSecp256k1 : Secp256k1 {
         return Pair(sigout, result == 1)
     }
 
-    override fun secKeyVerify(seckey: ByteArray): Boolean {
-        val result = Secp256k1CFunctions.secp256k1_ec_seckey_verify(Secp256k1Context.getContext(), seckey);
-        return result == 1;
+    override fun secKeyVerify(privkey: ByteArray): Boolean {
+        return Secp256k1CFunctions.secp256k1_ec_seckey_verify(Secp256k1Context.getContext(), privkey) == 1
     }
 
-    override fun pubkeyCreate(seckey: ByteArray): ByteArray {
-        return Secp256k1CFunctions.secp256k1_ec_pubkey_create(Secp256k1Context.getContext(), seckey)
+    override fun pubkeyCreate(privkey: ByteArray): ByteArray {
+        return Secp256k1CFunctions.secp256k1_ec_pubkey_create(Secp256k1Context.getContext(), privkey)
     }
 
     override fun pubkeyParse(pubkey: ByteArray): ByteArray {
         return Secp256k1CFunctions.secp256k1_ec_pubkey_parse(Secp256k1Context.getContext(), pubkey)
     }
 
-    override fun cleanup() {
-        return Secp256k1CFunctions.secp256k1_context_destroy(Secp256k1Context.getContext())
-    }
-
     override fun privKeyNegate(privkey: ByteArray): ByteArray {
         return Secp256k1CFunctions.secp256k1_ec_privkey_negate(Secp256k1Context.getContext(), privkey)
     }
 
-    override fun privKeyTweakMul(privkey: ByteArray, tweak: ByteArray): ByteArray {
-        return Secp256k1CFunctions.secp256k1_ec_privkey_tweak_mul(Secp256k1Context.getContext(), privkey, tweak)
-    }
-
     override fun privKeyTweakAdd(privkey: ByteArray, tweak: ByteArray): ByteArray {
         return Secp256k1CFunctions.secp256k1_ec_privkey_tweak_add(Secp256k1Context.getContext(), privkey, tweak)
     }
 
+    override fun privKeyTweakMul(privkey: ByteArray, tweak: ByteArray): ByteArray {
+        return Secp256k1CFunctions.secp256k1_ec_privkey_tweak_mul(Secp256k1Context.getContext(), privkey, tweak)
+    }
+
     override fun pubKeyNegate(pubkey: ByteArray): ByteArray {
         return Secp256k1CFunctions.secp256k1_ec_pubkey_negate(Secp256k1Context.getContext(), pubkey)
     }
@@ -72,12 +68,12 @@ public object NativeSecp256k1 : Secp256k1 {
         return Secp256k1CFunctions.secp256k1_ec_pubkey_tweak_mul(Secp256k1Context.getContext(), pubkey, tweak)
     }
 
-    override fun pubKeyAdd(pubkey1: ByteArray, pubkey2: ByteArray): ByteArray {
-        return Secp256k1CFunctions.secp256k1_ec_pubkey_add(Secp256k1Context.getContext(), pubkey1, pubkey2)
+    override fun pubKeyCombine(pubkeys: Array<ByteArray>): ByteArray {
+        return Secp256k1CFunctions.secp256k1_ec_pubkey_combine(Secp256k1Context.getContext(), pubkeys)
     }
 
-    override fun ecdh(seckey: ByteArray, pubkey: ByteArray): ByteArray {
-        return Secp256k1CFunctions.secp256k1_ecdh(Secp256k1Context.getContext(), seckey, pubkey)
+    override fun ecdh(privkey: ByteArray, pubkey: ByteArray): ByteArray {
+        return Secp256k1CFunctions.secp256k1_ecdh(Secp256k1Context.getContext(), privkey, pubkey)
     }
 
     override fun ecdsaRecover(sig: ByteArray, message: ByteArray, recid: Int): ByteArray {
@@ -87,4 +83,16 @@ public object NativeSecp256k1 : Secp256k1 {
     override fun compact2der(sig: ByteArray): ByteArray {
         return Secp256k1CFunctions.secp256k1_compact_to_der(Secp256k1Context.getContext(), sig)
     }
+
+    override fun verifySchnorr(signature: ByteArray, data: ByteArray, pub: ByteArray): Boolean {
+        return Secp256k1CFunctions.secp256k1_schnorrsig_verify(Secp256k1Context.getContext(), signature, data, pub) == 1
+    }
+
+    override fun signSchnorr(data: ByteArray, sec: ByteArray, auxrand32: ByteArray?): ByteArray {
+        return Secp256k1CFunctions.secp256k1_schnorrsig_sign(Secp256k1Context.getContext(), data, sec, auxrand32)
+    }
+
+    override fun cleanup() {
+        return Secp256k1CFunctions.secp256k1_context_destroy(Secp256k1Context.getContext())
+    }
 }

native/build-android.sh

@@ -35,7 +35,7 @@ export STRIP=$ANDROID_NDK/toolchains/llvm/prebuilt/$TOOLCHAIN/bin/$TOOLTARGET-st
 cd secp256k1
 
 ./autogen.sh
-./configure CFLAGS=-fpic --host=$TARGET --enable-experimental --enable-module_ecdh --enable-module-recovery --enable-benchmark=no --enable-shared=no --enable-exhaustive-tests=no --enable-tests=no
+./configure CFLAGS=-fpic --host=$TARGET --enable-experimental --enable-module_ecdh --enable-module-recovery --enable-module-schnorrsig --enable-benchmark=no --enable-shared=no --enable-exhaustive-tests=no --enable-tests=no
 make clean
 make
 

native/build-ios.sh

@@ -6,7 +6,7 @@ cp xconfigure.sh secp256k1
 cd secp256k1
 
 ./autogen.sh
-sh xconfigure.sh --enable-experimental --enable-module_ecdh --enable-module-recovery --enable-benchmark=no --enable-shared=no --enable-exhaustive-tests=no --enable-tests=no
+sh xconfigure.sh --enable-experimental --enable-module_ecdh --enable-module-recovery --enable-module-schnorrsig --enable-benchmark=no --enable-shared=no --enable-exhaustive-tests=no --enable-tests=no
 
 mkdir -p ../build/ios
 cp -v _build/universal/* ../build/ios/

native/build.gradle.kts

@@ -1,6 +1,10 @@
 import org.gradle.internal.os.OperatingSystem
 
-evaluationDependsOn(":jni:android")
+val includeAndroid = System.getProperty("includeAndroid")?.toBoolean() ?: true
+
+if (includeAndroid) {
+    evaluationDependsOn(":jni:android")
+}
 
 val currentOs = OperatingSystem.current()
 val bash = if (currentOs.isWindows) "bash.exe" else "bash"
@@ -39,34 +43,39 @@ val buildSecp256k1Ios by tasks.creating(Exec::class) {
     commandLine(bash, "build-ios.sh")
 }
 
-val buildSecp256k1Android by tasks.creating {
-    group = "build"
-    buildSecp256k1.dependsOn(this)
-}
-fun creatingBuildSecp256k1Android(arch: String) = tasks.creating(Exec::class) {
-    group = "build"
-    buildSecp256k1Android.dependsOn(this)
+if (includeAndroid) {
 
-    inputs.files(projectDir.resolve("build-android.sh"))
-    outputs.dir(projectDir.resolve("build/android/$arch"))
-
-    workingDir = projectDir
-
-    val toolchain = when {
-        currentOs.isLinux -> "linux-x86_64"
-        currentOs.isMacOsX -> "darwin-x86_64"
-        currentOs.isWindows -> "windows-x86_64"
-        else -> error("No Android toolchain defined for this OS: $currentOs")
+    val buildSecp256k1Android by tasks.creating {
+        group = "build"
+        buildSecp256k1.dependsOn(this)
     }
-    environment("TOOLCHAIN", toolchain)
-    environment("ARCH", arch)
-    environment("ANDROID_NDK", (project(":jni:android").extensions["android"] as com.android.build.gradle.LibraryExtension).ndkDirectory)
-    commandLine(bash, "build-android.sh")
+
+    fun creatingBuildSecp256k1Android(arch: String) = tasks.creating(Exec::class) {
+        group = "build"
+        buildSecp256k1Android.dependsOn(this)
+
+        inputs.files(projectDir.resolve("build-android.sh"))
+        outputs.dir(projectDir.resolve("build/android/$arch"))
+
+        workingDir = projectDir
+
+        val toolchain = when {
+            currentOs.isLinux -> "linux-x86_64"
+            currentOs.isMacOsX -> "darwin-x86_64"
+            currentOs.isWindows -> "windows-x86_64"
+            else -> error("No Android toolchain defined for this OS: $currentOs")
+        }
+        environment("TOOLCHAIN", toolchain)
+        environment("ARCH", arch)
+        environment("ANDROID_NDK", (project(":jni:android").extensions["android"] as com.android.build.gradle.LibraryExtension).ndkDirectory)
+        commandLine(bash, "build-android.sh")
+    }
+
+    val buildSecp256k1AndroidX86_64 by creatingBuildSecp256k1Android("x86_64")
+    val buildSecp256k1AndroidX86 by creatingBuildSecp256k1Android("x86")
+    val buildSecp256k1AndroidArm64v8a by creatingBuildSecp256k1Android("arm64-v8a")
+    val buildSecp256k1AndroidArmeabiv7a by creatingBuildSecp256k1Android("armeabi-v7a")
 }
-val buildSecp256k1AndroidX86_64 by creatingBuildSecp256k1Android("x86_64")
-val buildSecp256k1AndroidX86 by creatingBuildSecp256k1Android("x86")
-val buildSecp256k1AndroidArm64v8a by creatingBuildSecp256k1Android("arm64-v8a")
-val buildSecp256k1AndroidArmeabiv7a by creatingBuildSecp256k1Android("armeabi-v7a")
 
 val clean by tasks.creating {
     group = "build"

native/build.sh

@@ -15,7 +15,6 @@ if [ "$TARGET" == "mingw" ]; then
   CONF_OPTS="CFLAGS=-fPIC --host=x86_64-w64-mingw32"
 elif [ "$TARGET" == "linux" ]; then
   CONF_OPTS="CFLAGS=-fPIC"
-  [ "$CROSS" == "1" ] && sudo apt -y install libgmp-dev
 elif [ "$TARGET" == "darwin" ]; then
   CONF_OPTS="--host=x86_64-w64-darwin"
 else
@@ -24,7 +23,7 @@ else
 fi
 
 ./autogen.sh
-./configure $CONF_OPTS --enable-experimental --enable-module_ecdh --enable-module-recovery --enable-benchmark=no --enable-shared=no --enable-exhaustive-tests=no --enable-tests=no
+./configure $CONF_OPTS --enable-experimental --enable-module_ecdh --enable-module-recovery --enable-module-schnorrsig --enable-benchmark=no --enable-shared=no --enable-exhaustive-tests=no --enable-tests=no
 make clean
 make
 

settings.gradle.kts

@@ -5,16 +5,32 @@ pluginManagement {
         jcenter()
     }
 }
-rootProject.name = "secp256k1"
+rootProject.name = "secp256k1-kmp"
+
+// We use a property defined in `local.properties` to know whether we should build the android application or not.
+// For example, iOS developers may want to skip that most of the time.
+val skipAndroid = File("$rootDir/local.properties").takeIf { it.exists() }
+    ?.inputStream()?.use { java.util.Properties().apply { load(it) } }
+    ?.run { getProperty("skip.android", "false")?.toBoolean() }
+    ?: false
+
+// Use system properties to inject the property in other gradle build files.
+System.setProperty("includeAndroid", (!skipAndroid).toString())
 
 include(
     ":native",
     ":jni",
-    ":jni:android",
     ":jni:jvm",
     ":jni:jvm:darwin",
     ":jni:jvm:linux",
     ":jni:jvm:mingw",
     ":jni:jvm:all",
     ":tests"
-)
+)
+
+if (!skipAndroid) {
+    print("building android library")
+    include(":jni:android")
+} else {
+    print("skipping android build")
+}

src/commonMain/kotlin/fr/acinq/secp256k1/Secp256k1.kt

@@ -20,60 +20,153 @@ import kotlin.jvm.JvmStatic
 
 public interface Secp256k1 {
 
-    public fun verify(signature: ByteArray, data: ByteArray, pub: ByteArray): Boolean
+    /**
+     * Verify an ECDSA signature.
+     *
+     * @param signature signature using either compact encoding (64 bytes) or der-encoding.
+     * @param message message signed.
+     * @param pubkey signer's public key.
+     */
+    public fun verify(signature: ByteArray, message: ByteArray, pubkey: ByteArray): Boolean
 
-    public fun sign(data: ByteArray, sec: ByteArray): ByteArray
+    /**
+     * Create a normalized ECDSA signature.
+     *
+     * @param message message to sign.
+     * @param privkey signer's private key.
+     */
+    public fun sign(message: ByteArray, privkey: ByteArray): ByteArray
 
+    /**
+     * Verify a Schnorr signature.
+     *
+     * @param signature 64 bytes signature.
+     * @param message message signed.
+     * @param pubkey signer's x-only public key (32 bytes).
+     */
+    public fun verifySchnorr(signature: ByteArray, data: ByteArray, pub: ByteArray): Boolean
+
+    /**
+     * Create a Schnorr signature.
+     *
+     * @param message message to sign.
+     * @param privkey signer's private key.
+     * @param auxrand32 32 bytes of fresh randomness (optional).
+     */
+    public fun signSchnorr(data: ByteArray, sec: ByteArray, auxrand32: ByteArray?): ByteArray
+
+   /**
+     * Convert an ECDSA signature to a normalized lower-S form (bitcoin standardness rule).
+     * Returns the normalized signature and a boolean set to true if the input signature was not normalized.
+     *
+     * @param sig signature that should be normalized.
+     */
     public fun signatureNormalize(sig: ByteArray): Pair<ByteArray, Boolean>
 
-    public fun secKeyVerify(seckey: ByteArray): Boolean
+    /**
+     * Verify the validity of a private key.
+     */
+    public fun secKeyVerify(privkey: ByteArray): Boolean
 
-    public fun pubkeyCreate(seckey: ByteArray): ByteArray
+    /**
+     * Get the public key corresponding to the given private key.
+     * Returns the uncompressed public key (65 bytes).
+     */
+    public fun pubkeyCreate(privkey: ByteArray): ByteArray
 
+    /**
+     * Parse a serialized public key.
+     * Returns the uncompressed public key (65 bytes).
+     */
     public fun pubkeyParse(pubkey: ByteArray): ByteArray
 
-    public fun cleanup()
-
+    /**
+     * Negate the given private key.
+     */
     public fun privKeyNegate(privkey: ByteArray): ByteArray
 
-    public fun privKeyTweakMul(privkey: ByteArray, tweak: ByteArray): ByteArray
-
+    /**
+     * Tweak a private key by adding tweak to it.
+     */
     public fun privKeyTweakAdd(privkey: ByteArray, tweak: ByteArray): ByteArray
 
+    /**
+     * Tweak a private key by multiplying it by a tweak.
+     */
+    public fun privKeyTweakMul(privkey: ByteArray, tweak: ByteArray): ByteArray
+
+    /**
+     * Negate the given public key.
+     * Returns the uncompressed public key (65 bytes).
+     */
     public fun pubKeyNegate(pubkey: ByteArray): ByteArray
 
+    /**
+     * Tweak a public key by adding tweak times the generator to it.
+     * Returns the uncompressed public key (65 bytes).
+     */
     public fun pubKeyTweakAdd(pubkey: ByteArray, tweak: ByteArray): ByteArray
 
+    /**
+     * Tweak a public key by multiplying it by a tweak value.
+     * Returns the uncompressed public key (65 bytes).
+     */
     public fun pubKeyTweakMul(pubkey: ByteArray, tweak: ByteArray): ByteArray
 
-    public fun pubKeyAdd(pubkey1: ByteArray, pubkey2: ByteArray): ByteArray
+    /**
+     * Add a number of public keys together.
+     * Returns the uncompressed public key (65 bytes).
+     */
+    public fun pubKeyCombine(pubkeys: Array<ByteArray>): ByteArray
 
-    public fun ecdh(seckey: ByteArray, pubkey: ByteArray): ByteArray
+    /**
+     * Compute an elliptic curve Diffie-Hellman secret.
+     */
+    public fun ecdh(privkey: ByteArray, pubkey: ByteArray): ByteArray
 
+    /**
+     * Recover a public key from an ECDSA signature.
+     *
+     * @param sig ecdsa compact signature (64 bytes).
+     * @param message message signed.
+     * @param recid recoveryId (should have been provided with the signature to allow recovery).
+     */
     public fun ecdsaRecover(sig: ByteArray, message: ByteArray, recid: Int): ByteArray
 
+    /**
+     * Convert a compact ECDSA signature (64 bytes) to a der-encoded ECDSA signature.
+     */
     public fun compact2der(sig: ByteArray): ByteArray
 
-    public fun pubKeyCompress(pubkey: ByteArray) : ByteArray {
+    /**
+     * Serialize a public key to compact form (33 bytes).
+     */
+    public fun pubKeyCompress(pubkey: ByteArray): ByteArray {
         return when {
             pubkey.size == 33 && (pubkey[0] == 2.toByte() || pubkey[0] == 3.toByte()) -> pubkey
             pubkey.size == 65 && pubkey[0] == 4.toByte() -> {
-                val pub1 = pubkey.copyOf(33)
-                pub1[0] = if (pubkey.last() % 2 == 0) 2.toByte() else 3.toByte()
-                pub1
+                val compressed = pubkey.copyOf(33)
+                compressed[0] = if (pubkey.last() % 2 == 0) 2.toByte() else 3.toByte()
+                compressed
             }
             else -> throw Secp256k1Exception("invalid public key")
         }
     }
 
+    /**
+     * Delete the secp256k1 context from dynamic memory.
+     */
+    public fun cleanup()
+
     public companion object : Secp256k1 by getSecpk256k1() {
-        @JvmStatic public fun get(): Secp256k1 = this
+        @JvmStatic
+        public fun get(): Secp256k1 = this
     }
 }
 
 internal expect fun getSecpk256k1(): Secp256k1
 
 public class Secp256k1Exception : RuntimeException {
-    public constructor() : super() {}
-    public constructor(message: String?) : super(message) {}
+    public constructor() : super()
+    public constructor(message: String?) : super(message)
 }

src/jvmMain/kotlin/fr/acinq/secp256k1/Secp256k1Jvm.kt

@@ -20,12 +20,12 @@ import java.util.*
 
 
 private fun tryLoad(platform: String): Secp256k1? {
-    try {
-        val cls = Class.forName("fr.acinq.secp256k1.jni.NativeSecp256k1${platform.capitalize(Locale.ROOT)}Loader")
+    return try {
+        val cls = Class.forName("fr.acinq.secp256k1.jni.NativeSecp256k1${platform.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.ROOT) else it.toString() }}Loader")
         val load = cls.getMethod("load")
-        return load.invoke(null) as Secp256k1
+        load.invoke(null) as Secp256k1
     } catch (ex: ClassNotFoundException) {
-        return null
+        null
     }
 }
 

src/nativeInterop/cinterop/libsecp256k1.def

@@ -1,10 +1,10 @@
 package = secp256k1
 
-headers = secp256k1.h secp256k1_ecdh.h secp256k1_recovery.h
-headerFilter = secp256k1/** secp256k1_ecdh.h secp256k1_recovery.h secp256k1.h
+headers = secp256k1.h secp256k1_ecdh.h secp256k1_recovery.h secp256k1_extrakeys.h secp256k1_schnorrsig.h
+headerFilter = secp256k1/** secp256k1_ecdh.h secp256k1_recovery.h secp256k1_extrakeys.h secp256k1_schnorrsig.h secp256k1.h
 
 libraryPaths.linux = c/secp256k1/build/linux/
-linkerOpts.linux = -L/usr/lib64 -L/usr/lib/x86_64-linux-gnu -L/usr/local/lib -lgmp
+linkerOpts.linux = -L/usr/lib64 -L/usr/lib/x86_64-linux-gnu -L/usr/local/lib
 
 libraryPaths.ios = c/secp256k1/build/ios/ /usr/local/lib
 linkerOpts.ios = -framework Security -framework Foundation

src/nativeMain/kotlin/fr/acinq/secp256k1/Secp256k1Native.kt

@@ -9,7 +9,7 @@ public object Secp256k1Native : Secp256k1 {
 
     private val ctx: CPointer<secp256k1_context> by lazy {
         secp256k1_context_create((SECP256K1_FLAGS_TYPE_CONTEXT or SECP256K1_FLAGS_BIT_CONTEXT_SIGN or SECP256K1_FLAGS_BIT_CONTEXT_VERIFY).toUInt())
-            ?: error("Could not create segp256k1 context")
+            ?: error("Could not create secp256k1 context")
     }
 
     private fun Int.requireSuccess(message: String): Int = if (this != 1) throw Secp256k1Exception(message) else this
@@ -55,31 +55,31 @@ public object Secp256k1Native : Secp256k1 {
         return pinned.addressOf(0)
     }
 
-    public override fun verify(signature: ByteArray, data: ByteArray, pub: ByteArray): Boolean {
-        require(data.size == 32)
-        require(pub.size == 33 || pub.size == 65)
+    public override fun verify(signature: ByteArray, message: ByteArray, pubkey: ByteArray): Boolean {
+        require(message.size == 32)
+        require(pubkey.size == 33 || pubkey.size == 65)
         memScoped {
-            val nPubkey = allocPublicKey(pub)
-            val nData = toNat(data)
+            val nPubkey = allocPublicKey(pubkey)
+            val nMessage = toNat(message)
             val nSig = allocSignature(signature)
-            return secp256k1_ecdsa_verify(ctx, nSig.ptr, nData, nPubkey.ptr) == 1
+            return secp256k1_ecdsa_verify(ctx, nSig.ptr, nMessage, nPubkey.ptr) == 1
         }
     }
 
-    public override fun sign(data: ByteArray, sec: ByteArray): ByteArray {
-        require(sec.size == 32)
-        require(data.size == 32)
+    public override fun sign(message: ByteArray, privkey: ByteArray): ByteArray {
+        require(privkey.size == 32)
+        require(message.size == 32)
         memScoped {
-            val nSec = toNat(sec)
-            val nData = toNat(data)
+            val nPrivkey = toNat(privkey)
+            val nMessage = toNat(message)
             val nSig = alloc<secp256k1_ecdsa_signature>()
-            secp256k1_ecdsa_sign(ctx, nSig.ptr, nData, nSec, null, null).requireSuccess("secp256k1_ecdsa_sign() failed")
+            secp256k1_ecdsa_sign(ctx, nSig.ptr, nMessage, nPrivkey, null, null).requireSuccess("secp256k1_ecdsa_sign() failed")
             return serializeSignature(nSig)
         }
     }
 
     public override fun signatureNormalize(sig: ByteArray): Pair<ByteArray, Boolean> {
-        require(sig.size == 64 || sig.size in 70..73)
+        require(sig.size >= 64){ "invalid signature ${Hex.encode(sig)}" }
         memScoped {
             val nSig = allocSignature(sig)
             val isHighS = secp256k1_ecdsa_signature_normalize(ctx, nSig.ptr, nSig.ptr)
@@ -87,20 +87,20 @@ public object Secp256k1Native : Secp256k1 {
         }
     }
 
-    public override fun secKeyVerify(seckey: ByteArray): Boolean {
-        require(seckey.size == 32)
+    public override fun secKeyVerify(privkey: ByteArray): Boolean {
+        if (privkey.size != 32) return false
         memScoped {
-            val nSec = toNat(seckey)
-            return secp256k1_ec_seckey_verify(ctx, nSec) == 1
+            val nPrivkey = toNat(privkey)
+            return secp256k1_ec_seckey_verify(ctx, nPrivkey) == 1
         }
     }
 
-    public override fun pubkeyCreate(seckey: ByteArray): ByteArray {
-        require(seckey.size == 32)
+    public override fun pubkeyCreate(privkey: ByteArray): ByteArray {
+        require(privkey.size == 32)
         memScoped {
-            val nSec = toNat(seckey)
+            val nPrivkey = toNat(privkey)
             val nPubkey = alloc<secp256k1_pubkey>()
-            secp256k1_ec_pubkey_create(ctx, nPubkey.ptr, nSec).requireSuccess("secp256k1_ec_pubkey_create() failed")
+            secp256k1_ec_pubkey_create(ctx, nPubkey.ptr, nPrivkey).requireSuccess("secp256k1_ec_pubkey_create() failed")
             return serializePubkey(nPubkey)
         }
     }
@@ -113,10 +113,6 @@ public object Secp256k1Native : Secp256k1 {
         }
     }
 
-    public override fun cleanup() {
-        secp256k1_context_destroy(ctx)
-    }
-
     public override fun privKeyNegate(privkey: ByteArray): ByteArray {
         require(privkey.size == 32)
         memScoped {
@@ -127,17 +123,6 @@ public object Secp256k1Native : Secp256k1 {
         }
     }
 
-    public override fun privKeyTweakMul(privkey: ByteArray, tweak: ByteArray): ByteArray {
-        require(privkey.size == 32)
-        memScoped {
-            val multiplied = privkey.copyOf()
-            val natMul = toNat(multiplied)
-            val natTweak = toNat(tweak)
-            secp256k1_ec_privkey_tweak_mul(ctx, natMul, natTweak).requireSuccess("secp256k1_ec_privkey_tweak_mul() failed")
-            return multiplied
-        }
-    }
-
     public override fun privKeyTweakAdd(privkey: ByteArray, tweak: ByteArray): ByteArray {
         require(privkey.size == 32)
         memScoped {
@@ -149,6 +134,17 @@ public object Secp256k1Native : Secp256k1 {
         }
     }
 
+    public override fun privKeyTweakMul(privkey: ByteArray, tweak: ByteArray): ByteArray {
+        require(privkey.size == 32)
+        memScoped {
+            val multiplied = privkey.copyOf()
+            val natMul = toNat(multiplied)
+            val natTweak = toNat(tweak)
+            secp256k1_ec_privkey_tweak_mul(ctx, natMul, natTweak).requireSuccess("secp256k1_ec_privkey_tweak_mul() failed")
+            return multiplied
+        }
+    }
+
     public override fun pubKeyNegate(pubkey: ByteArray): ByteArray {
         require(pubkey.size == 33 || pubkey.size == 65)
         memScoped {
@@ -178,26 +174,24 @@ public object Secp256k1Native : Secp256k1 {
         }
     }
 
-    public override fun pubKeyAdd(pubkey1: ByteArray, pubkey2: ByteArray): ByteArray {
-        require(pubkey1.size == 33 || pubkey1.size == 65)
-        require(pubkey2.size == 33 || pubkey2.size == 65)
+    public override fun pubKeyCombine(pubkeys: Array<ByteArray>): ByteArray {
+        pubkeys.forEach { require(it.size == 33 || it.size == 65) }
         memScoped {
-            val nPubkey1 = allocPublicKey(pubkey1)
-            val nPubkey2 = allocPublicKey(pubkey2)
+            val nPubkeys = pubkeys.map { allocPublicKey(it).ptr }
             val combined = alloc<secp256k1_pubkey>()
-            secp256k1_ec_pubkey_combine(ctx, combined.ptr, cValuesOf(nPubkey1.ptr, nPubkey2.ptr), 2.convert()).requireSuccess("secp256k1_ec_pubkey_combine() failed")
+            secp256k1_ec_pubkey_combine(ctx, combined.ptr, nPubkeys.toCValues(), pubkeys.size.convert()).requireSuccess("secp256k1_ec_pubkey_combine() failed")
             return serializePubkey(combined)
         }
     }
 
-    public override fun ecdh(seckey: ByteArray, pubkey: ByteArray): ByteArray {
-        require(seckey.size == 32)
+    public override fun ecdh(privkey: ByteArray, pubkey: ByteArray): ByteArray {
+        require(privkey.size == 32)
         require(pubkey.size == 33 || pubkey.size == 65)
         memScoped {
             val nPubkey = allocPublicKey(pubkey)
-            val nSeckey = toNat(seckey)
+            val nPrivkey = toNat(privkey)
             val output = allocArray<UByteVar>(32)
-            secp256k1_ecdh(ctx, output, nPubkey.ptr, nSeckey, null, null).requireSuccess("secp256k1_ecdh() failed")
+            secp256k1_ecdh(ctx, output, nPubkey.ptr, nPrivkey, null, null).requireSuccess("secp256k1_ecdh() failed")
             return output.readBytes(32)
         }
     }
@@ -227,6 +221,42 @@ public object Secp256k1Native : Secp256k1 {
             return natOutput.readBytes(len.value.toInt())
         }
     }
+
+    override fun verifySchnorr(signature: ByteArray, data: ByteArray, pub: ByteArray): Boolean {
+        require(signature.size == 64)
+        require(data.size == 32)
+        require(pub.size == 32)
+        memScoped {
+            val nPub = toNat(pub)
+            val pubkey = alloc<secp256k1_xonly_pubkey>()
+            secp256k1_xonly_pubkey_parse(ctx, pubkey.ptr, nPub).requireSuccess("secp256k1_xonly_pubkey_parse() failed")
+            val nData = toNat(data)
+            val nSig = toNat(signature)
+            return secp256k1_schnorrsig_verify(ctx, nSig, nData, 32, pubkey.ptr) == 1
+        }
+    }
+
+    override fun signSchnorr(data: ByteArray, sec: ByteArray, auxrand32: ByteArray?): ByteArray {
+        require(sec.size == 32)
+        require(data.size == 32)
+        auxrand32?.let { require(it.size == 32) }
+        memScoped {
+            val nSec = toNat(sec)
+            val nData = toNat(data)
+            val nAuxrand32 = auxrand32?.let { toNat(it) }
+            val nSig = allocArray<UByteVar>(64)
+            val keypair = alloc<secp256k1_keypair>()
+            secp256k1_keypair_create(ctx, keypair.ptr, nSec).requireSuccess("secp256k1_keypair_create() failed")
+            secp256k1_schnorrsig_sign(ctx, nSig, nData, keypair.ptr, nAuxrand32).requireSuccess("secp256k1_ecdsa_sign() failed")
+            return nSig.readBytes(64)
+        }
+    }
+    
+    public override fun cleanup() {
+        secp256k1_context_destroy(ctx)
+    }
+
+
 }
 
 internal actual fun getSecpk256k1(): Secp256k1 = Secp256k1Native

tests/build.gradle.kts

@@ -1,11 +1,16 @@
+
 plugins {
     kotlin("multiplatform")
-    id("com.android.library")
+    if (System.getProperty("includeAndroid")?.toBoolean() == true) {
+        id("com.android.library")
+    }
 }
 
 kotlin {
     explicitApi()
 
+    val includeAndroid = System.getProperty("includeAndroid")?.toBoolean() ?: true
+
     val commonMain by sourceSets.getting {
         dependencies {
             implementation(rootProject)
@@ -13,6 +18,7 @@ kotlin {
     }
     val commonTest by sourceSets.getting {
         dependencies {
+            implementation(kotlin("test-common"))
             implementation(kotlin("test-annotations-common"))
         }
     }
@@ -29,17 +35,19 @@ kotlin {
         }
     }
 
-    android {
-        compilations.all {
-            kotlinOptions.jvmTarget = "1.8"
-        }
-        sourceSets["androidMain"].dependencies {
-            implementation(project(":jni:android"))
-        }
-        sourceSets["androidTest"].dependencies {
-            implementation(kotlin("test-junit"))
-            implementation("androidx.test.ext:junit:1.1.1")
-            implementation("androidx.test.espresso:espresso-core:3.2.0")
+    if (includeAndroid) {
+        android {
+            compilations.all {
+                kotlinOptions.jvmTarget = "1.8"
+            }
+            sourceSets["androidMain"].dependencies {
+                implementation(project(":jni:android"))
+            }
+            sourceSets["androidTest"].dependencies {
+                implementation(kotlin("test-junit"))
+                implementation("androidx.test.ext:junit:1.1.2")
+                implementation("androidx.test.espresso:espresso-core:3.3.0")
+            }
         }
     }
 
@@ -48,23 +56,26 @@ kotlin {
     ios()
 }
 
-android {
-    defaultConfig {
-        compileSdkVersion(30)
-        minSdkVersion(21)
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-    }
+val includeAndroid = System.getProperty("includeAndroid")?.toBoolean() ?: true
+if (includeAndroid) {
+    extensions.configure<com.android.build.gradle.LibraryExtension>("android") {
+        defaultConfig {
+            compileSdkVersion(30)
+            minSdkVersion(21)
+            testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        }
 
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_1_8
-    }
+        compileOptions {
+            sourceCompatibility = JavaVersion.VERSION_1_8
+            targetCompatibility = JavaVersion.VERSION_1_8
+        }
 
-    sourceSets["main"].manifest.srcFile("src/androidMain/AndroidManifest.xml")
+        sourceSets["main"].manifest.srcFile("src/androidMain/AndroidManifest.xml")
 
-    afterEvaluate {
-        tasks.withType<com.android.build.gradle.tasks.factory.AndroidUnitTest>().all {
-            enabled = false
+        afterEvaluate {
+            tasks.withType<com.android.build.gradle.tasks.factory.AndroidUnitTest>().all {
+                enabled = false
+            }
         }
     }
-}
+}

tests/src/commonTest/kotlin/fr/acinq/secp256k1/Secp256k1Test.kt

@@ -3,272 +3,357 @@ package fr.acinq.secp256k1
 import kotlin.random.Random
 import kotlin.test.*
 
-
-/**
- * This class holds test cases defined for testing this library.
- */
 class Secp256k1Test {
-    //TODO improve comments/add more tests
 
     @Test
-    fun testVerifyPos() {
-        var result: Boolean
-        val data: ByteArray = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()) //sha256hash of "testing"
-        val sig: ByteArray = Hex.decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase())
-        val pub: ByteArray = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase())
-        result = Secp256k1.verify(sig, data, pub)
-        assertTrue(result, "testVerifyPos")
-        val sigCompact: ByteArray = Hex.decode("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase())
-        result = Secp256k1.verify(sigCompact, data, pub)
-        assertTrue(result, "testVerifyPos")
+    fun verifyValidPrivateKey() {
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        assertTrue(Secp256k1.secKeyVerify(priv))
     }
 
     @Test
-    fun testVerifyNeg() {
-        var result: Boolean
-        val data: ByteArray = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A91".toLowerCase()) //sha256hash of "testing"
-        val sig: ByteArray = Hex.decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".toLowerCase())
-        val pub: ByteArray = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase())
-        result = Secp256k1.verify(sig, data, pub)
-        assertFalse(result, "testVerifyNeg")
+    fun verifyInvalidPrivateKey() {
+        val invalidSize = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A106353001")
+        assertFalse(Secp256k1.secKeyVerify(invalidSize))
+        val curveOrder = Hex.decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141".lowercase())
+        assertFalse(Secp256k1.secKeyVerify(curveOrder))
+        val zero = Hex.decode("0000000000000000000000000000000000000000000000000000000000000000".lowercase())
+        assertFalse(Secp256k1.secKeyVerify(zero))
     }
 
     @Test
-    fun testSecKeyVerifyPos() {
-        var result: Boolean
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        result = Secp256k1.secKeyVerify(sec)
-        assertTrue(result, "testSecKeyVerifyPos")
-    }
-
-    @Test
-    fun testSecKeyVerifyNeg() {
-        var result: Boolean
-        val sec: ByteArray = Hex.decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase())
-        result = Secp256k1.secKeyVerify(sec)
-        assertFalse(result, "testSecKeyVerifyNeg")
-    }
-
-    @Test
-    fun testPubKeyCreatePos() {
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val resultArr: ByteArray = Secp256k1.pubkeyCreate(sec)
-        val pubkeyString: String = Hex.encode(resultArr).toUpperCase()
+    fun createValidPublicKey() {
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val pub = Secp256k1.pubkeyCreate(priv)
         assertEquals(
             "04C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6",
-            pubkeyString,
-            "testPubKeyCreatePos"
+            Hex.encode(pub).uppercase(),
         )
     }
 
     @Test
-    fun testPubKeyCreateNeg() {
-        val sec: ByteArray = Hex.decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase())
-        assertFailsWith<Secp256k1Exception> {
-            Secp256k1.pubkeyCreate(sec)
-        }
+    fun createInvalidPublicKey() {
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyCreate(Hex.decode("0000000000000000000000000000000000000000000000000000000000000000".lowercase())) }
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyCreate(Hex.decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141".lowercase())) }
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyCreate(Hex.decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".lowercase())) }
     }
 
     @Test
-    fun testPubkeyCompress() {
+    fun compressPublicKey() {
         val pub = Hex.decode("04C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6")
         val compressed = Secp256k1.pubKeyCompress(pub)
-        assertEquals("02C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D", Hex.encode(compressed).toUpperCase())
+        assertEquals("02C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D", Hex.encode(compressed).uppercase())
     }
 
     @Test
-    fun testPubKeyNegatePos() {
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val pubkey: ByteArray = Secp256k1.pubkeyCreate(sec)
-        val pubkeyString: String = Hex.encode(pubkey).toUpperCase()
+    fun negatePublicKey() {
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val pub = Secp256k1.pubkeyCreate(priv)
         assertEquals(
             "04C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6",
-            pubkeyString,
-            "testPubKeyCreatePos"
+            Hex.encode(pub).uppercase(),
         )
-        val pubkey1: ByteArray = Secp256k1.pubKeyNegate(pubkey)
-        val pubkeyString1: String = Hex.encode(pubkey1).toUpperCase()
+        assertEquals(
+            "02C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D",
+            Hex.encode(Secp256k1.pubKeyCompress(pub)).uppercase()
+        )
+        val npub = Secp256k1.pubKeyNegate(pub)
         assertEquals(
             "04C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2DDEFC12B6B8E73968536514302E69ED1DDB24B999EFEE79C12D03AB17E79E1989",
-            pubkeyString1,
-            "testPubKeyNegatePos"
+            Hex.encode(npub).uppercase(),
         )
+        assertEquals(
+            "03C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D",
+            Hex.encode(Secp256k1.pubKeyCompress(npub)).uppercase()
+        )
+        val nnpub = Secp256k1.pubKeyNegate(npub)
+        assertContentEquals(pub, nnpub)
     }
 
     @Test
-    fun testPubKeyParse() {
-        val pub: ByteArray = Hex.decode("02C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D".toLowerCase())
-        val resultArr: ByteArray = Secp256k1.pubkeyParse(pub)
-        val pubkeyString: String = Hex.encode(resultArr).toUpperCase()
+    fun parsePublicKey() {
+        val pub = Hex.decode("02C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D".lowercase())
+        val parsed1 = Secp256k1.pubkeyParse(pub)
         assertEquals(
             "04C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6",
-            pubkeyString,
-            "testPubKeyAdd"
+            Hex.encode(parsed1).uppercase(),
         )
+        val parsed2 = Secp256k1.pubkeyParse(parsed1)
+        assertContentEquals(parsed1, parsed2)
     }
 
     @Test
-    fun testPubKeyAdd() {
-        val pub1: ByteArray = Hex.decode("041b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f70beaf8f588b541507fed6a642c5ab42dfdf8120a7f639de5122d47a69a8e8d1".toLowerCase())
-        val pub2: ByteArray = Hex.decode("044d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d07662a3eada2d0fe208b6d257ceb0f064284662e857f57b66b54c198bd310ded36d0".toLowerCase())
-        val pub3: ByteArray = Secp256k1.pubKeyAdd(pub1, pub2)
-        val pubkeyString: String = Hex.encode(pub3).toUpperCase()
+    fun parseInvalidPublicKey() {
+        // Not a valid curve point.
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyParse(Hex.decode("02FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".lowercase())) }
+        // Invalid first byte.
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyParse(Hex.decode("02C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6".lowercase())) }
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyParse(Hex.decode("03C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6".lowercase())) }
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyParse(Hex.decode("05C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D2103ED494718C697AC9AEBCFD19612E224DB46661011863ED2FC54E71861E2A6".lowercase())) }
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyParse(Hex.decode("01C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D".lowercase())) }
+        assertFailsWith<Secp256k1Exception> { Secp256k1.pubkeyParse(Hex.decode("04C591A8FF19AC9C4E4E5793673B83123437E975285E7B442F4EE2654DFFCA5E2D".lowercase())) }
+    }
+
+    @Test
+    fun combinePublicKeys() {
+        // Mixture of compressed and uncompressed public keys.
+        val pub1 = Hex.decode("041b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f70beaf8f588b541507fed6a642c5ab42dfdf8120a7f639de5122d47a69a8e8d1")
+        val pub2 = Hex.decode("044d4b6cd1361032ca9bd2aeb9d900aa4d45d9ead80ac9423374c451a7254d07662a3eada2d0fe208b6d257ceb0f064284662e857f57b66b54c198bd310ded36d0")
+        val pub3 = Hex.decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619")
+        val pub4 = Secp256k1.pubKeyCombine(arrayOf(pub1, pub2, pub3))
         assertEquals(
-            "04531FE6068134503D2723133227C867AC8FA6C83C537E9A44C3C5BDBDCB1FE3379E92C265E71E481BA82A84675A47AC705A200FCD524E92D93B0E7386F26A5458",
-            pubkeyString,
-            "testPubKeyAdd"
+            "042C0B7CF95324A07D05398B240174DC0C2BE444D96B159AA6C7F7B1E668680991AE31A9C671A36543F46CEA8FCE6984608AA316AA0472A7EED08847440218CB2F",
+            Hex.encode(pub4).uppercase(),
         )
     }
 
     @Test
-    fun testSignPos() {
-        val data: ByteArray = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()) //sha256hash of "testing"
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val resultArr: ByteArray = Secp256k1.sign(data, sec)
-        val sigString: String = Hex.encode(resultArr).toUpperCase()
+    fun createEcdsaSignature() {
+        val message = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".lowercase()) //sha256hash of "testing"
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val sig = Secp256k1.sign(message, priv)
         assertEquals(
             "182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9",
-            sigString,
-            "testSignPos"
+            Hex.encode(sig).uppercase(),
         )
     }
 
     @Test
-    fun testSignatureNormalize() {
-        val data: ByteArray = Hex.decode("30440220182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A202201C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9".toLowerCase())
-        val (resultArr, isHighS) = Secp256k1.signatureNormalize(data)
-        val sigString: String = Hex.encode(resultArr).toUpperCase()
+    fun normalizeEcdsaSignature() {
+        val normalizedDerSig = Hex.decode("30440220182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A202201C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9".lowercase())
+        val (normalizedCompactSig1, wasNotNormalized1) = Secp256k1.signatureNormalize(normalizedDerSig)
+        assertFalse(wasNotNormalized1)
         assertEquals(
             "182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9",
-            sigString,
-            "testSignPos"
+            Hex.encode(normalizedCompactSig1).uppercase(),
+        )
+        val notNormalizedDerSig = Hex.decode("30450220182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A2022100E3990C925DEE3F780C50774AF120B062E0080D86D8C721C6E32F10DBACA57A58".lowercase())
+        val (normalizedCompactSig2, wasNotNormalized2) = Secp256k1.signatureNormalize(notNormalizedDerSig)
+        assertTrue(wasNotNormalized2)
+        assertEquals(
+            "182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9",
+            Hex.encode(normalizedCompactSig2).uppercase(),
+        )
+        val normalizedCompactSig = Hex.decode("182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9".lowercase())
+        val (normalizedCompactSig3, wasNotNormalized3) = Secp256k1.signatureNormalize(normalizedCompactSig)
+        assertFalse(wasNotNormalized3)
+        assertEquals(
+            "182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9",
+            Hex.encode(normalizedCompactSig3).uppercase(),
+        )
+        val notNormalizedCompactSig = Hex.decode("182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A2E3990C925DEE3F780C50774AF120B062E0080D86D8C721C6E32F10DBACA57A58".lowercase())
+        val (normalizedCompactSig4, wasNotNormalized4) = Secp256k1.signatureNormalize(notNormalizedCompactSig)
+        assertTrue(wasNotNormalized4)
+        assertEquals(
+            "182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9",
+            Hex.encode(normalizedCompactSig4).uppercase(),
         )
-        assertFalse(isHighS, "isHighS")
     }
 
     @Test
-    fun testSignNeg() {
-        val data: ByteArray = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()) //sha256hash of "testing"
-        val sec: ByteArray = Hex.decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".toLowerCase())
+    fun failToCreateEcdsaSignature() {
+        val message = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".lowercase()) //sha256hash of "testing"
+        val priv = Hex.decode("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF".lowercase())
         assertFailsWith<Secp256k1Exception> {
-            Secp256k1.sign(data, sec)
+            Secp256k1.sign(message, priv)
         }
     }
 
     @Test
-    fun testSignCompactPos() {
-        val data: ByteArray = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()) //sha256hash of "testing"
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val resultArr: ByteArray = Secp256k1.sign(data, sec)
-        val sigString: String = Hex.encode(resultArr).toUpperCase()
+    fun createCompactEcdsaSignature() {
+        val message = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".lowercase()) //sha256hash of "testing"
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val sig = Secp256k1.sign(message, priv)
         assertEquals(
             "182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9",
-            sigString,
-            "testSignCompactPos"
+            Hex.encode(sig).uppercase(),
         )
     }
 
     @Test
-    fun testPrivKeyTweakNegate() {
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val sec1: ByteArray = Secp256k1.privKeyNegate(sec)
+    fun verifyValidEcdsaSignatures() {
+        val message = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".lowercase()) //sha256hash of "testing"
+        val sig = Hex.decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".lowercase())
+        val pub = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".lowercase())
+        assertTrue(Secp256k1.verify(sig, message, pub))
+        val sigCompact = Hex.decode("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".lowercase())
+        assertTrue(Secp256k1.verify(sigCompact, message, pub))
+    }
+
+    @Test
+    fun verifyInvalidEcdsaSignatures() {
+        val message = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A91".lowercase()) //sha256hash of "testing"
+        val sig = Hex.decode("3044022079BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F817980220294F14E883B3F525B5367756C2A11EF6CF84B730B36C17CB0C56F0AAB2C98589".lowercase())
+        val pub = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".lowercase())
+        assertFalse(Secp256k1.verify(sig, message, pub))
+    }
+
+    @Test
+    fun negatePrivateKey() {
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val npriv = Secp256k1.privKeyNegate(priv)
         assertEquals(
             "981A9A7DD677A622518DA068D66D5F824E5F22F084B8A0E2F195B5662F300C11",
-            Hex.encode(sec1).toUpperCase(),
-            "testPrivKeyNegate"
+            Hex.encode(npriv).uppercase(),
         )
-        val sec2: ByteArray = Secp256k1.privKeyNegate(sec1)
-        assertTrue(sec.contentEquals(sec2))
+        val nnpriv: ByteArray = Secp256k1.privKeyNegate(npriv)
+        assertContentEquals(priv, nnpriv)
     }
 
     @Test
-    fun testPrivKeyTweakAdd_1() {
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val data: ByteArray = Hex.decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()) //sha256hash of "tweak"
-        val resultArr: ByteArray = Secp256k1.privKeyTweakAdd(sec, data)
-        val sigString: String = Hex.encode(resultArr).toUpperCase()
+    fun addTweakToPrivateKey() {
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val tweak = Hex.decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".lowercase())
+        val tweakedPriv = Secp256k1.privKeyTweakAdd(priv, tweak)
         assertEquals(
             "A168571E189E6F9A7E2D657A4B53AE99B909F7E712D1C23CED28093CD57C88F3",
-            sigString,
-            "testPrivKeyAdd_1"
+            Hex.encode(tweakedPriv).uppercase(),
         )
     }
 
     @Test
-    fun testPrivKeyTweakMul_1() {
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val data: ByteArray = Hex.decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()) //sha256hash of "tweak"
-        val resultArr: ByteArray = Secp256k1.privKeyTweakMul(sec, data)
-        val sigString: String = Hex.encode(resultArr).toUpperCase()
+    fun multiplyPrivateKeyWithTweak() {
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val tweak = Hex.decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".lowercase())
+        val tweakedPriv = Secp256k1.privKeyTweakMul(priv, tweak)
         assertEquals(
             "97F8184235F101550F3C71C927507651BD3F1CDB4A5A33B8986ACF0DEE20FFFC",
-            sigString,
-            "testPrivKeyMul_1"
+            Hex.encode(tweakedPriv).uppercase(),
         )
     }
 
     @Test
-    fun testPrivKeyTweakAdd_2() {
-        val pub: ByteArray = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase())
-        val data: ByteArray = Hex.decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()) //sha256hash of "tweak"
-        val resultArr: ByteArray = Secp256k1.pubKeyTweakAdd(pub, data)
-        val sigString: String = Hex.encode(resultArr).toUpperCase()
+    fun addTweakToPublicKey() {
+        val pub = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".lowercase())
+        val tweak = Hex.decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".lowercase())
+        val tweakedPub = Secp256k1.pubKeyTweakAdd(pub, tweak)
         assertEquals(
             "0411C6790F4B663CCE607BAAE08C43557EDC1A4D11D88DFCB3D841D0C6A941AF525A268E2A863C148555C48FB5FBA368E88718A46E205FABC3DBA2CCFFAB0796EF",
-            sigString,
-            "testPrivKeyAdd_2"
+            Hex.encode(tweakedPub).uppercase(),
         )
     }
 
     @Test
-    fun testPrivKeyTweakMul_2() {
-        val pub: ByteArray = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase())
-        val data: ByteArray = Hex.decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".toLowerCase()) //sha256hash of "tweak"
-        val resultArr: ByteArray = Secp256k1.pubKeyTweakMul(pub, data)
-        val sigString: String = Hex.encode(resultArr).toUpperCase()
+    fun multiplyPublicKeyWithTweak() {
+        val pub = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".lowercase())
+        val tweak = Hex.decode("3982F19BEF1615BCCFBB05E321C10E1D4CBA3DF0E841C2E41EEB6016347653C3".lowercase())
+        val tweakedPub = Secp256k1.pubKeyTweakMul(pub, tweak)
         assertEquals(
             "04E0FE6FE55EBCA626B98A807F6CAF654139E14E5E3698F01A9A658E21DC1D2791EC060D4F412A794D5370F672BC94B722640B5F76914151CFCA6E712CA48CC589",
-            sigString,
-            "testPrivKeyMul_2"
+            Hex.encode(tweakedPub).uppercase(),
         )
     }
 
     @Test
-    fun testCreateECDHSecret() {
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val pub: ByteArray = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".toLowerCase())
-        val resultArr: ByteArray = Secp256k1.ecdh(sec, pub)
-        val ecdhString: String = Hex.encode(resultArr).toUpperCase()
+    fun createEcdhSecret() {
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val pub = Hex.decode("040A629506E1B65CD9D2E0BA9C75DF9C4FED0DB16DC9625ED14397F0AFC836FAE595DC53F8B0EFE61E703075BD9B143BAC75EC0E19F82A2208CAEB32BE53414C40".lowercase())
+        val secret = Secp256k1.ecdh(priv, pub)
         assertEquals(
             "2A2A67007A926E6594AF3EB564FC74005B37A9C8AEF2033C4552051B5C87F043",
-            ecdhString,
-            "testCreateECDHSecret"
+            Hex.encode(secret).uppercase(),
         )
     }
 
     @Test
-    fun testEcdsaRecover() {
-        val data: ByteArray = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".toLowerCase()) //sha256hash of "testing"
-        val sec: ByteArray = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".toLowerCase())
-        val pub: ByteArray = Secp256k1.pubkeyCreate(sec)
-        val sig: ByteArray = Secp256k1.sign(data, sec)
-        val pub0: ByteArray = Secp256k1.ecdsaRecover(sig, data, 0)
-        val pub1: ByteArray = Secp256k1.ecdsaRecover(sig, data, 1)
-        assertTrue(pub.contentEquals(pub0) || pub.contentEquals(pub1), "testEcdsaRecover")
+    fun createSymmetricEcdhSecret() {
+        val priv1 = Hex.decode("3580a881ac24eb00530a51235c42bcb65424ba121e2e7d910a70fa531a578d21")
+        val pub1 = Secp256k1.pubkeyCreate(priv1)
+        val priv2 = Hex.decode("f6a353f7a5de654501c3495acde7450293f74d09086c2b7c9a4e524248d0daac")
+        val pub2 = Secp256k1.pubkeyCreate(priv2)
+        val secret1 = Secp256k1.ecdh(priv1, pub2)
+        val secret2 = Secp256k1.ecdh(priv2, pub1)
+        assertContentEquals(secret1, secret2)
     }
 
     @Test
-    fun testCompactToDER() {
-        val sig: ByteArray = Hex.decode("182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9".toLowerCase()) //sha256hash of "testing"
-        val der: ByteArray = Secp256k1.compact2der(sig)
+    fun recoverPublicKeyFromEcdsaSignature() {
+        val message = Hex.decode("CF80CD8AED482D5D1527D7DC72FCEFF84E6326592848447D2DC0B0E87DFC9A90".lowercase()) //sha256hash of "testing"
+        val priv = Hex.decode("67E56582298859DDAE725F972992A07C6C4FB9F62A8FFF58CE3CA926A1063530".lowercase())
+        val pub = Secp256k1.pubkeyCreate(priv)
+        val sig = Secp256k1.sign(message, priv)
+        val pub0 = Secp256k1.ecdsaRecover(sig, message, 0)
+        val pub1 = Secp256k1.ecdsaRecover(sig, message, 1)
+        assertTrue(pub.contentEquals(pub0) || pub.contentEquals(pub1))
+    }
+
+    @Test
+    fun convertCompactEcdsaSignatureToDer() {
+        val compact = Hex.decode("182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A21C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9".lowercase()) //sha256hash of "testing"
+        val der = Secp256k1.compact2der(compact)
         assertEquals(
             "30440220182A108E1448DC8F1FB467D06A0F3BB8EA0533584CB954EF8DA112F1D60E39A202201C66F36DA211C087F3AF88B50EDF4F9BDAA6CF5FD6817E74DCA34DB12390C6E9",
-            Hex.encode(der).toUpperCase(),
+            Hex.encode(der).uppercase(),
         )
     }
 
     @Test
-    fun testFormatConversion() {
+    fun testSchnorrSignature() {
+        val seckey = Hex.decode("0000000000000000000000000000000000000000000000000000000000000003")
+        val msg = Hex.decode("0000000000000000000000000000000000000000000000000000000000000000")
+        val auxrand32 = Hex.decode("0000000000000000000000000000000000000000000000000000000000000000")
+        val sig = Secp256k1.signSchnorr(msg, seckey, auxrand32)
+        assertEquals(
+            "E907831F80848D1069A5371B402410364BDF1C5F8307B0084C55F1CE2DCA821525F66A4A85EA8B71E482A74F382D2CE5EBEEE8FDB2172F477DF4900D310536C0",
+            Hex.encode(sig).uppercase(),
+        )
+        val pubkey = Secp256k1.pubkeyCreate(seckey).drop(1).take(32).toByteArray()
+        assertEquals(
+            "F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9",
+            Hex.encode(pubkey).uppercase()
+        )
+        assertTrue(Secp256k1.verifySchnorr(sig, msg, pubkey))
+    }
+
+    @Test
+    fun testSchnorrTestVectors() {
+        // BIP340 test vectors copied from https://github.com/bitcoin/bips/blob/master/bip-0340/test-vectors.csv
+        val bip340TestVectors = """index,secret key,public key,aux_rand,message,signature,verification result,comment
+0,0000000000000000000000000000000000000000000000000000000000000003,F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9,0000000000000000000000000000000000000000000000000000000000000000,0000000000000000000000000000000000000000000000000000000000000000,E907831F80848D1069A5371B402410364BDF1C5F8307B0084C55F1CE2DCA821525F66A4A85EA8B71E482A74F382D2CE5EBEEE8FDB2172F477DF4900D310536C0,TRUE,
+1,B7E151628AED2A6ABF7158809CF4F3C762E7160F38B4DA56A784D9045190CFEF,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,0000000000000000000000000000000000000000000000000000000000000001,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,6896BD60EEAE296DB48A229FF71DFE071BDE413E6D43F917DC8DCF8C78DE33418906D11AC976ABCCB20B091292BFF4EA897EFCB639EA871CFA95F6DE339E4B0A,TRUE,
+2,C90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B14E5C9,DD308AFEC5777E13121FA72B9CC1B7CC0139715309B086C960E18FD969774EB8,C87AA53824B4D7AE2EB035A2B5BBBCCC080E76CDC6D1692C4B0B62D798E6D906,7E2D58D8B3BCDF1ABADEC7829054F90DDA9805AAB56C77333024B9D0A508B75C,5831AAEED7B44BB74E5EAB94BA9D4294C49BCF2A60728D8B4C200F50DD313C1BAB745879A5AD954A72C45A91C3A51D3C7ADEA98D82F8481E0E1E03674A6F3FB7,TRUE,
+3,0B432B2677937381AEF05BB02A66ECD012773062CF3FA2549E44F58ED2401710,25D1DFF95105F5253C4022F628A996AD3A0D95FBF21D468A1B33F8C160D8F517,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,7EB0509757E246F19449885651611CB965ECC1A187DD51B64FDA1EDC9637D5EC97582B9CB13DB3933705B32BA982AF5AF25FD78881EBB32771FC5922EFC66EA3,TRUE,test fails if msg is reduced modulo p or n
+4,,D69C3509BB99E412E68B0FE8544E72837DFA30746D8BE2AA65975F29D22DC7B9,,4DF3C3F68FCC83B27E9D42C90431A72499F17875C81A599B566C9889B9696703,00000000000000000000003B78CE563F89A0ED9414F5AA28AD0D96D6795F9C6376AFB1548AF603B3EB45C9F8207DEE1060CB71C04E80F593060B07D28308D7F4,TRUE,
+5,,EEFDEA4CDB677750A420FEE807EACF21EB9898AE79B9768766E4FAA04A2D4A34,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E17776969E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B,FALSE,public key not on the curve
+6,,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A14602975563CC27944640AC607CD107AE10923D9EF7A73C643E166BE5EBEAFA34B1AC553E2,FALSE,has_even_y(R) is false
+7,,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,1FA62E331EDBC21C394792D2AB1100A7B432B013DF3F6FF4F99FCB33E0E1515F28890B3EDB6E7189B630448B515CE4F8622A954CFE545735AAEA5134FCCDB2BD,FALSE,negated message
+8,,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E177769961764B3AA9B2FFCB6EF947B6887A226E8D7C93E00C5ED0C1834FF0D0C2E6DA6,FALSE,negated s value
+9,,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,0000000000000000000000000000000000000000000000000000000000000000123DDA8328AF9C23A94C1FEECFD123BA4FB73476F0D594DCB65C6425BD186051,FALSE,sG - eP is infinite. Test fails in single verification if has_even_y(inf) is defined as true and x(inf) as 0
+10,,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,00000000000000000000000000000000000000000000000000000000000000017615FBAF5AE28864013C099742DEADB4DBA87F11AC6754F93780D5A1837CF197,FALSE,sG - eP is infinite. Test fails in single verification if has_even_y(inf) is defined as true and x(inf) as 1
+11,,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,4A298DACAE57395A15D0795DDBFD1DCB564DA82B0F269BC70A74F8220429BA1D69E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B,FALSE,sig[0:32] is not an X coordinate on the curve
+12,,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F69E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B,FALSE,sig[0:32] is equal to field size
+13,,DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E177769FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141,FALSE,sig[32:64] is equal to curve order
+14,,FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC30,,243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89,6CFF5C3BA86C69EA4B7376F31A9BCB4F74C1976089B2D9963DA2E5543E17776969E89B4C5564D00349106B8497785DD7D1D713A8AE82B32FA79D5F7FC407D39B,FALSE,public key is not a valid X coordinate because it exceeds the field size"""
+
+        bip340TestVectors.split('\n').drop(1).forEach {
+            val testData = it.split(',')
+            val index = testData[0]
+            val seckey = Hex.decode(testData[1])
+            val pubkey = Hex.decode(testData[2])
+            val auxrand = if (testData[3].isEmpty()) null else Hex.decode(testData[3])
+            val msg = Hex.decode(testData[4])
+            val sig = testData[5]
+            val expected = when (testData[6]) {
+                "FALSE" -> false
+                else -> true
+            }
+            val comment = testData[7]
+
+            if (seckey.isNotEmpty()) {
+                val ourSig = Secp256k1.signSchnorr(msg, seckey, auxrand)
+                assertEquals(Hex.encode(ourSig).uppercase(), sig)
+            }
+            val result = try {
+                Secp256k1.verifySchnorr(Hex.decode(sig), msg, pubkey)
+            } catch (t: Throwable) {
+                false
+            }
+            assertEquals(expected, result, "test [$index, $comment] failed")
+        }
+    }
+
+    @Test
+    fun fuzzEcdsaSignVerify() {
         val random = Random.Default
 
         fun randomBytes(length: Int): ByteArray {
@@ -279,11 +364,13 @@ class Secp256k1Test {
 
         repeat(200) {
             val priv = randomBytes(32)
+            assertTrue(Secp256k1.secKeyVerify(priv))
             val pub = Secp256k1.pubkeyCreate(priv)
-            val data = randomBytes(32)
-            val sig = Secp256k1.sign(data, priv)
+            val message = randomBytes(32)
+            val sig = Secp256k1.sign(message, priv)
+            assertTrue(Secp256k1.verify(sig, message, pub))
             val der = Secp256k1.compact2der(sig)
-            Secp256k1.verify(der, data, pub)
+            assertTrue(Secp256k1.verify(der, message, pub))
         }
     }
 }