@qntx/nostr-native 0.13.0 → 0.15.0

package/NostrNative.podspec

@@ -25,7 +25,7 @@ Pod::Spec.new do |s|
   ]
 
   s.pod_target_xcconfig = {
-    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) ENABLE_MODULE_EXTRAKEYS=1 ENABLE_MODULE_SCHNORRSIG=1",
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) ENABLE_MODULE_ECDH=1 ENABLE_MODULE_EXTRAKEYS=1 ENABLE_MODULE_SCHNORRSIG=1",
   }
 
   load 'nitrogen/generated/ios/NostrNative+autolinking.rb'

package/android/CMakeLists.txt

@@ -7,7 +7,7 @@ set(CMAKE_CXX_STANDARD 20)
 
 # Vendored libsecp256k1 modules needed by cpp/nostr_core.c (its single-TU include of
 # vendor/secp256k1/src/secp256k1.c reads these defines).
-add_definitions(-DENABLE_MODULE_EXTRAKEYS -DENABLE_MODULE_SCHNORRSIG)
+add_definitions(-DENABLE_MODULE_ECDH -DENABLE_MODULE_EXTRAKEYS -DENABLE_MODULE_SCHNORRSIG)
 
 # C glue + C++ hybrid. nostr_core.c itself includes the vendored secp256k1.c — the only
 # separately-compiled vendor sources are the two precomputed tables below.

package/cpp/HybridNostrNative.cpp

@@ -29,6 +29,22 @@ std::shared_ptr<ArrayBuffer> HybridNostrNative::publicKey(
   return out;
 }
 
+std::shared_ptr<ArrayBuffer> HybridNostrNative::ecdhX(
+    const std::shared_ptr<ArrayBuffer>& secretKey,
+    const std::shared_ptr<ArrayBuffer>& publicKeyX) {
+  if (secretKey->size() != 32) {
+    throw std::invalid_argument("secretKey must be 32 bytes");
+  }
+  if (publicKeyX->size() != 32) {
+    throw std::invalid_argument("publicKeyX must be 32 bytes");
+  }
+  auto out = ArrayBuffer::allocate(32);
+  if (!nostr_native_ecdh_x(secretKey->data(), publicKeyX->data(), out->data())) {
+    throw std::invalid_argument("invalid ECDH input");
+  }
+  return out;
+}
+
 std::shared_ptr<ArrayBuffer> HybridNostrNative::sign(
     const std::shared_ptr<ArrayBuffer>& id,
     const std::shared_ptr<ArrayBuffer>& secretKey,

package/cpp/nostr_core.c

@@ -15,6 +15,7 @@
  */
 #include "../vendor/secp256k1/src/secp256k1.c"
 #include "../vendor/secp256k1/include/secp256k1_extrakeys.h"
+#include "../vendor/secp256k1/include/secp256k1_ecdh.h"
 #include "../vendor/secp256k1/include/secp256k1_schnorrsig.h"
 
 #include "nostr_core.h"
@@ -96,6 +97,34 @@ int nostr_core_public_key(const nostr_native_secp256k1_context *ctx,
   return ok ? NOSTR_CORE_OK : NOSTR_CORE_INVALID_INPUT;
 }
 
+/* ECDH hash function: writes the shared point's x coordinate, nothing else. */
+static int nostr_core_ecdh_xonly_hash(unsigned char *output, const unsigned char *x,
+                                    const unsigned char *y, void *data) {
+  (void)y;
+  (void)data;
+  memcpy(output, x, 32);
+  return 1;
+}
+
+int nostr_core_ecdh_x(const nostr_native_secp256k1_context *ctx, const unsigned char seckey[32],
+                      const unsigned char pubkey_x[32], unsigned char out32[32]) {
+  unsigned char compressed[33];
+  nostr_native_secp256k1_pubkey point;
+  int ok;
+
+  if (ctx == NULL || seckey == NULL || pubkey_x == NULL || out32 == NULL) {
+    return NOSTR_CORE_INVALID_INPUT;
+  }
+
+  compressed[0] = 0x02;
+  memcpy(compressed + 1, pubkey_x, 32);
+  ok = nostr_native_secp256k1_ec_pubkey_parse(ctx, &point, compressed, 33) &&
+       nostr_native_secp256k1_ecdh(ctx, out32, &point, seckey, nostr_core_ecdh_xonly_hash, NULL);
+  nostr_native_secp256k1_memclear_explicit(compressed, sizeof(compressed));
+  nostr_native_secp256k1_memclear_explicit(&point, sizeof(point));
+  return ok ? NOSTR_CORE_OK : NOSTR_CORE_INVALID_INPUT;
+}
+
 #ifdef NOSTR_NATIVE_TEST
 
 nostr_native_secp256k1_context *nostr_native_test_context(void) {

package/cpp/nostr_core.h

@@ -42,6 +42,13 @@ int nostr_core_sign(const nostr_native_secp256k1_context *ctx, const unsigned ch
 int nostr_core_public_key(const nostr_native_secp256k1_context *ctx,
                           const unsigned char seckey[32], unsigned char out_xonly[32]);
 
+/* Computes the ECDH shared point's x coordinate: `secp256k1_ecdh` with a hash function that
+ * copies the x coordinate only — the shared secret both NIP-04 (AES key) and NIP-44 (HKDF
+ * input) derive from. `pubkey_x` is lifted to an even-Y point as `0x02‖x`. Intermediates are
+ * wiped on every path. out32 gets the 32-byte x on NOSTR_CORE_OK. */
+int nostr_core_ecdh_x(const nostr_native_secp256k1_context *ctx, const unsigned char seckey[32],
+                      const unsigned char pubkey_x[32], unsigned char out32[32]);
+
 /* Secure wipe for platform layers that must clear caller-provided regions. */
 void nostr_core_wipe(void *ptr, size_t len);
 

package/cpp/nostr_native.c

@@ -36,6 +36,10 @@ static nostr_native_secp256k1_context *module_context(void) {
   return module_ctx;
 }
 
+int nostr_native_abi_version(void) {
+  return NOSTR_NATIVE_ABI_VERSION;
+}
+
 int nostr_native_verify_serialized(const unsigned char *serialized, size_t len,
                                    const unsigned char id[32],
                                    const unsigned char pubkey[32],
@@ -48,6 +52,11 @@ int nostr_native_public_key(const unsigned char seckey[32], unsigned char out_xo
   return nostr_core_public_key(module_context(), seckey, out_xonly) == NOSTR_CORE_OK;
 }
 
+int nostr_native_ecdh_x(const unsigned char seckey[32], const unsigned char pubkey_x[32],
+                        unsigned char out32[32]) {
+  return nostr_core_ecdh_x(module_context(), seckey, pubkey_x, out32) == NOSTR_CORE_OK;
+}
+
 int nostr_native_sign(const unsigned char id[32], const unsigned char seckey[32],
                       const unsigned char aux_rand[32], unsigned char out_sig[64]) {
   return nostr_core_sign(module_context(), id, seckey, aux_rand, out_sig) == NOSTR_CORE_OK;

package/cpp/nostr_native.h

@@ -7,6 +7,14 @@
 extern "C" {
 #endif
 
+/* Stable public C interface version. Bump when the export surface changes; embedders can check
+ * nostr_native_abi_version() at load time. v1: verify_serialized/public_key/sign.
+ * v2: adds ecdh_x. */
+#define NOSTR_NATIVE_ABI_VERSION 2
+
+/* Returns NOSTR_NATIVE_ABI_VERSION. */
+int nostr_native_abi_version(void);
+
 /**
  * Return 1 iff `sha256(serialized[0..len])` equals `id` and `sig` is a valid BIP-340 signature of
  * `id` for the x-only `pubkey`. `id`/`pubkey` are 32 bytes and `sig` is 64 bytes; NULL pointers
@@ -30,6 +38,15 @@ int nostr_native_public_key(const unsigned char seckey[32], unsigned char out_xo
 int nostr_native_sign(const unsigned char id[32], const unsigned char seckey[32],
                       const unsigned char aux_rand[32], unsigned char out_sig[64]);
 
+/**
+ * Write the 32-byte x coordinate of the ECDH shared point between `seckey` and `pubkey_x`
+ * (lifted even-Y) to `out32` — the shared secret NIP-04 and NIP-44 derive from. The caller must
+ * wipe `out32` and its own `seckey` copy when done. Returns 1 on success; 0 on NULL input, an
+ * invalid secret key, or a `pubkey_x` that does not lift to a curve point.
+ */
+int nostr_native_ecdh_x(const unsigned char seckey[32], const unsigned char pubkey_x[32],
+                        unsigned char out32[32]);
+
 #ifdef NOSTR_NATIVE_TEST
 /* Test-only entry points (host suite only): expose the SHA-256 and Schnorr halves individually
  * so BIP-340 vectors with arbitrary-length messages and raw SHA-256 vectors can run. */

package/dist/index.d.mts

@@ -1,15 +1,17 @@
-import { SerializedEventVerifier, SigningBackend } from "@qntx/nostr/core";
+import { NostrBackend } from "@qntx/nostr/core";
 //#region src/index.d.ts
 /**
- * `SerializedEventVerifier` backed by native libsecp256k1 — plug into `createEventVerifier` from
- * `@qntx/nostr/core`. The Nitro hybrid object is created once at module load.
+ * `NostrBackend["verifySerialized"]` backed by native libsecp256k1 — plug into
+ * `createEventVerifier` from `@qntx/nostr/core`. The Nitro hybrid object is created once at module
+ * load.
  */
-export declare const verifySerialized: SerializedEventVerifier;
+export declare const verifySerialized: NostrBackend["verifySerialized"];
 /**
- * `SigningBackend` backed by native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey,
- * signing)` or `Keys.generate(signing)` so signing runs on the same randomized context as
- * verification. Throws on an invalid secret key or wrong-length input.
+ * `NostrBackend` (without `ecdhX`, which lands in T4 with the native `ecdh_x` export) backed by
+ * native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey, signing)` or
+ * `Keys.generate(signing)` so signing runs on the same randomized context as verification. Throws
+ * on an invalid secret key or wrong-length input.
  */
-export declare const signing: SigningBackend;
+export declare const signing: NostrBackend;
 //#endregion
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -7,16 +7,20 @@ function asArrayBuffer(view) {
 	return new Uint8Array(view).buffer;
 }
 /**
-* `SerializedEventVerifier` backed by native libsecp256k1 — plug into `createEventVerifier` from
-* `@qntx/nostr/core`. The Nitro hybrid object is created once at module load.
+* `NostrBackend["verifySerialized"]` backed by native libsecp256k1 — plug into
+* `createEventVerifier` from `@qntx/nostr/core`. The Nitro hybrid object is created once at module
+* load.
 */
 const verifySerialized = (serializedUtf8, id, pubkey, sig) => nostrNative.verifySerialized(asArrayBuffer(serializedUtf8), asArrayBuffer(id), asArrayBuffer(pubkey), asArrayBuffer(sig));
 /**
-* `SigningBackend` backed by native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey,
-* signing)` or `Keys.generate(signing)` so signing runs on the same randomized context as
-* verification. Throws on an invalid secret key or wrong-length input.
+* `NostrBackend` (without `ecdhX`, which lands in T4 with the native `ecdh_x` export) backed by
+* native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey, signing)` or
+* `Keys.generate(signing)` so signing runs on the same randomized context as verification. Throws
+* on an invalid secret key or wrong-length input.
 */
 const signing = {
+	ecdhX: (secretKey, publicKeyX) => new Uint8Array(nostrNative.ecdhX(asArrayBuffer(secretKey), asArrayBuffer(publicKeyX))),
+	verifySerialized,
 	publicKey: (secretKey) => new Uint8Array(nostrNative.publicKey(asArrayBuffer(secretKey))),
 	sign: (id, secretKey, auxRand) => new Uint8Array(nostrNative.sign(asArrayBuffer(id), asArrayBuffer(secretKey), asArrayBuffer(auxRand)))
 };

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { NitroModules } from \"react-native-nitro-modules\";\n\nimport type { SerializedEventVerifier, SigningBackend } from \"@qntx/nostr/core\";\n\nimport type { NostrNative } from \"./specs/nostr-native.nitro.ts\";\n\nconst nostrNative = NitroModules.createHybridObject<NostrNative>(\"NostrNative\");\n\nfunction asArrayBuffer(view: Uint8Array): ArrayBuffer {\n  const { buffer, byteOffset, byteLength } = view;\n  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {\n    return buffer;\n  }\n  return new Uint8Array(view).buffer;\n}\n\n/**\n * `SerializedEventVerifier` backed by native libsecp256k1 — plug into `createEventVerifier` from\n * `@qntx/nostr/core`. The Nitro hybrid object is created once at module load.\n */\nexport const verifySerialized: SerializedEventVerifier = (serializedUtf8, id, pubkey, sig) =>\n  nostrNative.verifySerialized(\n    asArrayBuffer(serializedUtf8),\n    asArrayBuffer(id),\n    asArrayBuffer(pubkey),\n    asArrayBuffer(sig),\n  );\n\n/**\n * `SigningBackend` backed by native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey,\n * signing)` or `Keys.generate(signing)` so signing runs on the same randomized context as\n * verification. Throws on an invalid secret key or wrong-length input.\n */\nexport const signing: SigningBackend = {\n  publicKey: (secretKey) => new Uint8Array(nostrNative.publicKey(asArrayBuffer(secretKey))),\n  sign: (id, secretKey, auxRand) =>\n    new Uint8Array(\n      nostrNative.sign(asArrayBuffer(id), asArrayBuffer(secretKey), asArrayBuffer(auxRand)),\n    ),\n};\n"],"mappings":";;AAMA,MAAM,cAAc,aAAa,mBAAgC,aAAa;AAE9E,SAAS,cAAc,MAA+B;CACpD,MAAM,EAAE,QAAQ,YAAY,eAAe;CAC3C,IAAI,kBAAkB,eAAe,eAAe,KAAK,eAAe,OAAO,YAC7E,OAAO;CAET,OAAO,IAAI,WAAW,IAAI,CAAC,CAAC;AAC9B;;;;;AAMA,MAAa,oBAA6C,gBAAgB,IAAI,QAAQ,QACpF,YAAY,iBACV,cAAc,cAAc,GAC5B,cAAc,EAAE,GAChB,cAAc,MAAM,GACpB,cAAc,GAAG,CACnB;;;;;;AAOF,MAAa,UAA0B;CACrC,YAAY,cAAc,IAAI,WAAW,YAAY,UAAU,cAAc,SAAS,CAAC,CAAC;CACxF,OAAO,IAAI,WAAW,YACpB,IAAI,WACF,YAAY,KAAK,cAAc,EAAE,GAAG,cAAc,SAAS,GAAG,cAAc,OAAO,CAAC,CACtF;AACJ"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { NitroModules } from \"react-native-nitro-modules\";\n\nimport type { NostrBackend } from \"@qntx/nostr/core\";\n\nimport type { NostrNative } from \"./specs/nostr-native.nitro.ts\";\n\nconst nostrNative = NitroModules.createHybridObject<NostrNative>(\"NostrNative\");\n\nfunction asArrayBuffer(view: Uint8Array): ArrayBuffer {\n  const { buffer, byteOffset, byteLength } = view;\n  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {\n    return buffer;\n  }\n  return new Uint8Array(view).buffer;\n}\n\n/**\n * `NostrBackend[\"verifySerialized\"]` backed by native libsecp256k1 — plug into\n * `createEventVerifier` from `@qntx/nostr/core`. The Nitro hybrid object is created once at module\n * load.\n */\nexport const verifySerialized: NostrBackend[\"verifySerialized\"] = (\n  serializedUtf8,\n  id,\n  pubkey,\n  sig,\n) =>\n  nostrNative.verifySerialized(\n    asArrayBuffer(serializedUtf8),\n    asArrayBuffer(id),\n    asArrayBuffer(pubkey),\n    asArrayBuffer(sig),\n  );\n\n/**\n * `NostrBackend` (without `ecdhX`, which lands in T4 with the native `ecdh_x` export) backed by\n * native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey, signing)` or\n * `Keys.generate(signing)` so signing runs on the same randomized context as verification. Throws\n * on an invalid secret key or wrong-length input.\n */\nexport const signing: NostrBackend = {\n  ecdhX: (secretKey, publicKeyX) =>\n    new Uint8Array(nostrNative.ecdhX(asArrayBuffer(secretKey), asArrayBuffer(publicKeyX))),\n  verifySerialized,\n  publicKey: (secretKey) => new Uint8Array(nostrNative.publicKey(asArrayBuffer(secretKey))),\n  sign: (id, secretKey, auxRand) =>\n    new Uint8Array(\n      nostrNative.sign(asArrayBuffer(id), asArrayBuffer(secretKey), asArrayBuffer(auxRand)),\n    ),\n};\n"],"mappings":";;AAMA,MAAM,cAAc,aAAa,mBAAgC,aAAa;AAE9E,SAAS,cAAc,MAA+B;CACpD,MAAM,EAAE,QAAQ,YAAY,eAAe;CAC3C,IAAI,kBAAkB,eAAe,eAAe,KAAK,eAAe,OAAO,YAC7E,OAAO;CAET,OAAO,IAAI,WAAW,IAAI,CAAC,CAAC;AAC9B;;;;;;AAOA,MAAa,oBACX,gBACA,IACA,QACA,QAEA,YAAY,iBACV,cAAc,cAAc,GAC5B,cAAc,EAAE,GAChB,cAAc,MAAM,GACpB,cAAc,GAAG,CACnB;;;;;;;AAQF,MAAa,UAAwB;CACnC,QAAQ,WAAW,eACjB,IAAI,WAAW,YAAY,MAAM,cAAc,SAAS,GAAG,cAAc,UAAU,CAAC,CAAC;CACvF;CACA,YAAY,cAAc,IAAI,WAAW,YAAY,UAAU,cAAc,SAAS,CAAC,CAAC;CACxF,OAAO,IAAI,WAAW,YACpB,IAAI,WACF,YAAY,KAAK,cAAc,EAAE,GAAG,cAAc,SAAS,GAAG,cAAc,OAAO,CAAC,CACtF;AACJ"}

package/nitrogen/generated/shared/c++/HybridNostrNativeSpec.cpp

@@ -17,6 +17,7 @@ namespace margelo::nitro::nostrnative {
       prototype.registerHybridMethod("verifySerialized", &HybridNostrNativeSpec::verifySerialized);
       prototype.registerHybridMethod("publicKey", &HybridNostrNativeSpec::publicKey);
       prototype.registerHybridMethod("sign", &HybridNostrNativeSpec::sign);
+      prototype.registerHybridMethod("ecdhX", &HybridNostrNativeSpec::ecdhX);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridNostrNativeSpec.hpp

@@ -51,6 +51,7 @@ namespace margelo::nitro::nostrnative {
       virtual bool verifySerialized(const std::shared_ptr<ArrayBuffer>& serializedUtf8, const std::shared_ptr<ArrayBuffer>& id, const std::shared_ptr<ArrayBuffer>& pubkey, const std::shared_ptr<ArrayBuffer>& sig) = 0;
       virtual std::shared_ptr<ArrayBuffer> publicKey(const std::shared_ptr<ArrayBuffer>& secretKey) = 0;
       virtual std::shared_ptr<ArrayBuffer> sign(const std::shared_ptr<ArrayBuffer>& id, const std::shared_ptr<ArrayBuffer>& secretKey, const std::shared_ptr<ArrayBuffer>& auxRand) = 0;
+      virtual std::shared_ptr<ArrayBuffer> ecdhX(const std::shared_ptr<ArrayBuffer>& secretKey, const std::shared_ptr<ArrayBuffer>& publicKeyX) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qntx/nostr-native",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Native libsecp256k1 (Nitro) verification and signing backend for @qntx/nostr on React Native",
   "keywords": [
     "bip340",
@@ -61,17 +61,17 @@
     "@arethetypeswrong/cli": "0.18.5",
     "@noble/curves": "2.4.0",
     "@noble/hashes": "2.4.0",
-    "@qntx/nostr": "0.13.0",
+    "@qntx/nostr": "0.15.0",
     "@qntx/tsconfig": "1.0.1",
-    "@types/node": "26.6.4",
+    "@types/node": "26.6.5",
     "nitrogen": "0.37.1",
     "publint": "0.3.25",
     "react-native-nitro-modules": "0.37.1",
     "typescript": "7.0.2",
-    "vite-plus": "1.0.0"
+    "vite-plus": "1.2.0"
   },
   "peerDependencies": {
-    "@qntx/nostr": "^0.13.0",
+    "@qntx/nostr": "^0.15.0",
     "react-native": "*",
     "react-native-nitro-modules": "^0.37.1"
   },

package/vendor/secp256k1/src/modules/ecdh/main_impl.h

@@ -0,0 +1,79 @@
+/***********************************************************************
+ * Copyright (c) 2015 Andrew Poelstra                                  *
+ * Distributed under the MIT software license, see the accompanying    *
+ * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
+ ***********************************************************************/
+
+#ifndef SECP256K1_MODULE_ECDH_MAIN_H
+#define SECP256K1_MODULE_ECDH_MAIN_H
+
+#include "../../../include/secp256k1_ecdh.h"
+#include "../../ecmult_const_impl.h"
+
+static int ecdh_hash_function_sha256_impl(const nostr_native_secp256k1_hash_ctx *hash_ctx, unsigned char *output, const unsigned char *x32, const unsigned char *y32, void *data) {
+    unsigned char version = (y32[31] & 0x01) | 0x02;
+    nostr_native_secp256k1_sha256 sha;
+    (void)data;
+
+    nostr_native_secp256k1_sha256_initialize(&sha);
+    nostr_native_secp256k1_sha256_write(hash_ctx, &sha, &version, 1);
+    nostr_native_secp256k1_sha256_write(hash_ctx, &sha, x32, 32);
+    nostr_native_secp256k1_sha256_finalize(hash_ctx, &sha, output);
+    nostr_native_secp256k1_sha256_clear(&sha);
+
+    return 1;
+}
+
+static int ecdh_hash_function_sha256(unsigned char *output, const unsigned char *x32, const unsigned char *y32, void *data) {
+    return ecdh_hash_function_sha256_impl(nostr_native_secp256k1_get_hash_context(nostr_native_secp256k1_context_static), output, x32, y32, data);
+}
+
+const nostr_native_secp256k1_ecdh_hash_function nostr_native_secp256k1_ecdh_hash_function_sha256 = ecdh_hash_function_sha256;
+const nostr_native_secp256k1_ecdh_hash_function nostr_native_secp256k1_ecdh_hash_function_default = ecdh_hash_function_sha256;
+
+int nostr_native_secp256k1_ecdh(const nostr_native_secp256k1_context* ctx, unsigned char *output, const nostr_native_secp256k1_pubkey *point, const unsigned char *scalar, nostr_native_secp256k1_ecdh_hash_function hashfp, void *data) {
+    int ret = 0;
+    int overflow = 0;
+    nostr_native_secp256k1_gej res;
+    nostr_native_secp256k1_ge pt;
+    nostr_native_secp256k1_scalar s;
+    unsigned char x[32];
+    unsigned char y[32];
+
+    VERIFY_CHECK(ctx != NULL);
+    ARG_CHECK(output != NULL);
+    ARG_CHECK(point != NULL);
+    ARG_CHECK(scalar != NULL);
+
+    nostr_native_secp256k1_pubkey_load(ctx, &pt, point);
+    nostr_native_secp256k1_scalar_set_b32(&s, scalar, &overflow);
+
+    overflow |= nostr_native_secp256k1_scalar_is_zero(&s);
+    nostr_native_secp256k1_scalar_cmov(&s, &nostr_native_secp256k1_scalar_one, overflow);
+
+    nostr_native_secp256k1_ecmult_const(&res, &pt, &s);
+    nostr_native_secp256k1_ge_set_gej(&pt, &res);
+
+    /* Compute a hash of the point */
+    nostr_native_secp256k1_fe_normalize(&pt.x);
+    nostr_native_secp256k1_fe_normalize(&pt.y);
+    nostr_native_secp256k1_fe_get_b32(x, &pt.x);
+    nostr_native_secp256k1_fe_get_b32(y, &pt.y);
+
+    if (hashfp == NULL || hashfp == nostr_native_secp256k1_ecdh_hash_function_sha256) {
+        /* Use ctx-aware function by default */
+        ret = ecdh_hash_function_sha256_impl(nostr_native_secp256k1_get_hash_context(ctx), output, x, y, data);
+    } else {
+        ret = hashfp(output, x, y, data);
+    }
+
+    nostr_native_secp256k1_memclear_explicit(x, sizeof(x));
+    nostr_native_secp256k1_memclear_explicit(y, sizeof(y));
+    nostr_native_secp256k1_scalar_clear(&s);
+    nostr_native_secp256k1_ge_clear(&pt);
+    nostr_native_secp256k1_gej_clear(&res);
+
+    return !!ret & !overflow;
+}
+
+#endif /* SECP256K1_MODULE_ECDH_MAIN_H */