@openclaw/nostr 2026.5.20 → 2026.5.22

package/node_modules/nostr-tools/lib/types/signer.d.ts

@@ -0,0 +1,11 @@
+import { EventTemplate, VerifiedEvent } from './core.ts';
+export interface Signer {
+    getPublicKey(): Promise<string>;
+    signEvent(event: EventTemplate): Promise<VerifiedEvent>;
+}
+export declare class PlainKeySigner implements Signer {
+    private secretKey;
+    constructor(secretKey: Uint8Array);
+    getPublicKey(): Promise<string>;
+    signEvent(event: EventTemplate): Promise<VerifiedEvent>;
+}

package/node_modules/nostr-tools/lib/types/test-helpers.d.ts

@@ -0,0 +1,14 @@
+import { WebSocket } from 'mock-socket';
+import { type Event } from './pure.ts';
+export declare const MockWebSocketClient: typeof WebSocket;
+export declare function buildEvent(params: Partial<Event>): Event;
+export declare class MockRelay {
+    private _server;
+    url: string;
+    secretKeys: Uint8Array[];
+    preloadedEvents: Event[];
+    unresponsive: boolean;
+    constructor(url?: string | undefined);
+    get authors(): string[];
+    get ids(): string[];
+}

package/node_modules/nostr-tools/lib/types/utils.d.ts

@@ -0,0 +1,9 @@
+import type { NostrEvent } from './core.ts';
+export declare const utf8Decoder: TextDecoder;
+export declare const utf8Encoder: TextEncoder;
+export { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
+export declare function normalizeURL(url: string): string;
+export declare function insertEventIntoDescendingList(sortedArray: NostrEvent[], event: NostrEvent): NostrEvent[];
+export declare function insertEventIntoAscendingList(sortedArray: NostrEvent[], event: NostrEvent): NostrEvent[];
+export declare function binarySearch<T>(arr: T[], compare: (b: T) => number): [number, boolean];
+export declare function mergeReverseSortedLists(list1: NostrEvent[], list2: NostrEvent[]): NostrEvent[];

package/node_modules/nostr-tools/lib/types/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/nostr-tools/lib/types/wasm.d.ts

@@ -0,0 +1,8 @@
+import { Nostr as NostrWasm } from 'nostr-wasm';
+import { EventTemplate, Event, VerifiedEvent } from './core.ts';
+export declare function setNostrWasm(x: NostrWasm): void;
+export declare const generateSecretKey: () => Uint8Array;
+export declare const getPublicKey: (secretKey: Uint8Array) => string;
+export declare const finalizeEvent: (t: EventTemplate, secretKey: Uint8Array) => VerifiedEvent;
+export declare const verifyEvent: (event: Event) => event is VerifiedEvent;
+export * from './core.ts';

package/node_modules/nostr-tools/package.json

@@ -0,0 +1,330 @@
+{
+  "type": "module",
+  "name": "nostr-tools",
+  "version": "2.23.5",
+  "description": "Tools for making a Nostr client.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nbd-wtf/nostr-tools.git"
+  },
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "module": "./lib/esm/index.js",
+  "main": "./lib/cjs/index.js",
+  "types": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./index.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js",
+      "types": "./lib/types/index.d.ts"
+    },
+    "./core": {
+      "source": "./core.ts",
+      "import": "./lib/esm/core.js",
+      "require": "./lib/cjs/core.js",
+      "types": "./lib/types/core.d.ts"
+    },
+    "./pure": {
+      "source": "./pure.ts",
+      "import": "./lib/esm/pure.js",
+      "require": "./lib/cjs/pure.js",
+      "types": "./lib/types/pure.d.ts"
+    },
+    "./wasm": {
+      "source": "./wasm.ts",
+      "import": "./lib/esm/wasm.js",
+      "require": "./lib/cjs/wasm.js",
+      "types": "./lib/types/wasm.d.ts"
+    },
+    "./kinds": {
+      "source": "./kinds.ts",
+      "import": "./lib/esm/kinds.js",
+      "require": "./lib/cjs/kinds.js",
+      "types": "./lib/types/kinds.d.ts"
+    },
+    "./filter": {
+      "source": "./filter.ts",
+      "import": "./lib/esm/filter.js",
+      "require": "./lib/cjs/filter.js",
+      "types": "./lib/types/filter.d.ts"
+    },
+    "./abstract-relay": {
+      "source": "./abstract-relay.ts",
+      "import": "./lib/esm/abstract-relay.js",
+      "require": "./lib/cjs/abstract-relay.js",
+      "types": "./lib/types/abstract-relay.d.ts"
+    },
+    "./relay": {
+      "source": "./relay.ts",
+      "import": "./lib/esm/relay.js",
+      "require": "./lib/cjs/relay.js",
+      "types": "./lib/types/relay.d.ts"
+    },
+    "./abstract-pool": {
+      "source": "./abstract-pool.ts",
+      "import": "./lib/esm/abstract-pool.js",
+      "require": "./lib/cjs/abstract-pool.js",
+      "types": "./lib/types/abstract-pool.d.ts"
+    },
+    "./pool": {
+      "source": "./pool.ts",
+      "import": "./lib/esm/pool.js",
+      "require": "./lib/cjs/pool.js",
+      "types": "./lib/types/pool.d.ts"
+    },
+    "./references": {
+      "source": "./references.ts",
+      "import": "./lib/esm/references.js",
+      "require": "./lib/cjs/references.js",
+      "types": "./lib/types/references.d.ts"
+    },
+    "./nip04": {
+      "source": "./nip04.ts",
+      "import": "./lib/esm/nip04.js",
+      "require": "./lib/cjs/nip04.js",
+      "types": "./lib/types/nip04.d.ts"
+    },
+    "./nip05": {
+      "source": "./nip05.ts",
+      "import": "./lib/esm/nip05.js",
+      "require": "./lib/cjs/nip05.js",
+      "types": "./lib/types/nip05.d.ts"
+    },
+    "./nip06": {
+      "source": "./nip06.ts",
+      "import": "./lib/esm/nip06.js",
+      "require": "./lib/cjs/nip06.js",
+      "types": "./lib/types/nip06.d.ts"
+    },
+    "./nip07": {
+      "types": "./lib/types/nip07.d.ts"
+    },
+    "./nip10": {
+      "source": "./nip10.ts",
+      "import": "./lib/esm/nip10.js",
+      "require": "./lib/cjs/nip10.js",
+      "types": "./lib/types/nip10.d.ts"
+    },
+    "./nip11": {
+      "source": "./nip11.ts",
+      "import": "./lib/esm/nip11.js",
+      "require": "./lib/cjs/nip11.js",
+      "types": "./lib/types/nip11.d.ts"
+    },
+    "./nip13": {
+      "source": "./nip13.ts",
+      "import": "./lib/esm/nip13.js",
+      "require": "./lib/cjs/nip13.js",
+      "types": "./lib/types/nip13.d.ts"
+    },
+    "./nip17": {
+      "source": "./nip17.ts",
+      "import": "./lib/esm/nip17.js",
+      "require": "./lib/cjs/nip17.js",
+      "types": "./lib/types/nip17.d.ts"
+    },
+    "./nip18": {
+      "source": "./nip18.ts",
+      "import": "./lib/esm/nip18.js",
+      "require": "./lib/cjs/nip18.js",
+      "types": "./lib/types/nip18.d.ts"
+    },
+    "./nip19": {
+      "source": "./nip19.ts",
+      "import": "./lib/esm/nip19.js",
+      "require": "./lib/cjs/nip19.js",
+      "types": "./lib/types/nip19.d.ts"
+    },
+    "./nip21": {
+      "source": "./nip21.ts",
+      "import": "./lib/esm/nip21.js",
+      "require": "./lib/cjs/nip21.js",
+      "types": "./lib/types/nip21.d.ts"
+    },
+    "./nip22": {
+      "source": "./nip22.ts",
+      "import": "./lib/esm/nip22.js",
+      "require": "./lib/cjs/nip22.js",
+      "types": "./lib/types/nip22.d.ts"
+    },
+    "./nip25": {
+      "source": "./nip25.ts",
+      "import": "./lib/esm/nip25.js",
+      "require": "./lib/cjs/nip25.js",
+      "types": "./lib/types/nip25.d.ts"
+    },
+    "./nip27": {
+      "source": "./nip27.ts",
+      "import": "./lib/esm/nip27.js",
+      "require": "./lib/cjs/nip27.js",
+      "types": "./lib/types/nip27.d.ts"
+    },
+    "./nip28": {
+      "source": "./nip28.ts",
+      "import": "./lib/esm/nip28.js",
+      "require": "./lib/cjs/nip28.js",
+      "types": "./lib/types/nip28.d.ts"
+    },
+    "./nip29": {
+      "source": "./nip29.ts",
+      "import": "./lib/esm/nip29.js",
+      "require": "./lib/cjs/nip29.js",
+      "types": "./lib/types/nip29.d.ts"
+    },
+    "./nip30": {
+      "source": "./nip30.ts",
+      "import": "./lib/esm/nip30.js",
+      "require": "./lib/cjs/nip30.js",
+      "types": "./lib/types/nip30.d.ts"
+    },
+    "./nip39": {
+      "source": "./nip39.ts",
+      "import": "./lib/esm/nip39.js",
+      "require": "./lib/cjs/nip39.js",
+      "types": "./lib/types/nip39.d.ts"
+    },
+    "./nip42": {
+      "source": "./nip42.ts",
+      "import": "./lib/esm/nip42.js",
+      "require": "./lib/cjs/nip42.js",
+      "types": "./lib/types/nip42.d.ts"
+    },
+    "./nip44": {
+      "source": "./nip44.ts",
+      "import": "./lib/esm/nip44.js",
+      "require": "./lib/cjs/nip44.js",
+      "types": "./lib/types/nip44.d.ts"
+    },
+    "./nip46": {
+      "source": "./nip46.ts",
+      "import": "./lib/esm/nip46.js",
+      "require": "./lib/cjs/nip46.js",
+      "types": "./lib/types/nip46.d.ts"
+    },
+    "./nip49": {
+      "source": "./nip49.ts",
+      "import": "./lib/esm/nip49.js",
+      "require": "./lib/cjs/nip49.js",
+      "types": "./lib/types/nip49.d.ts"
+    },
+    "./nip54": {
+      "source": "./nip54.ts",
+      "import": "./lib/esm/nip54.js",
+      "require": "./lib/cjs/nip54.js",
+      "types": "./lib/types/nip54.d.ts"
+    },
+    "./nip57": {
+      "source": "./nip57.ts",
+      "import": "./lib/esm/nip57.js",
+      "require": "./lib/cjs/nip57.js",
+      "types": "./lib/types/nip57.d.ts"
+    },
+    "./nip59": {
+      "source": "./nip59.ts",
+      "import": "./lib/esm/nip59.js",
+      "require": "./lib/cjs/nip59.js",
+      "types": "./lib/types/nip59.d.ts"
+    },
+    "./nip58": {
+      "source": "./nip58.ts",
+      "import": "./lib/esm/nip58.js",
+      "require": "./lib/cjs/nip58.js",
+      "types": "./lib/types/nip58.d.ts"
+    },
+    "./nip75": {
+      "source": "./nip75.ts",
+      "import": "./lib/esm/nip75.js",
+      "require": "./lib/cjs/nip75.js",
+      "types": "./lib/types/nip75.d.ts"
+    },
+    "./nip94": {
+      "source": "./nip94.ts",
+      "import": "./lib/esm/nip94.js",
+      "require": "./lib/cjs/nip94.js",
+      "types": "./lib/types/nip94.d.ts"
+    },
+    "./nip98": {
+      "source": "./nip98.ts",
+      "import": "./lib/esm/nip98.js",
+      "require": "./lib/cjs/nip98.js",
+      "types": "./lib/types/nip98.d.ts"
+    },
+    "./nip99": {
+      "source": "./nip99.ts",
+      "import": "./lib/esm/nip99.js",
+      "require": "./lib/cjs/nip99.js",
+      "types": "./lib/types/nip99.d.ts"
+    },
+    "./nipb7": {
+      "source": "./nipb7.ts",
+      "import": "./lib/esm/nipb7.js",
+      "require": "./lib/cjs/nipb7.js",
+      "types": "./lib/types/nipb7.d.ts"
+    },
+    "./fakejson": {
+      "source": "./fakejson.ts",
+      "import": "./lib/esm/fakejson.js",
+      "require": "./lib/cjs/fakejson.js",
+      "types": "./lib/types/fakejson.d.ts"
+    },
+    "./signer": {
+      "source": "./signer.ts",
+      "import": "./lib/esm/signer.js",
+      "require": "./lib/cjs/signer.js",
+      "types": "./lib/types/signer.d.ts"
+    },
+    "./utils": {
+      "source": "./utils.ts",
+      "import": "./lib/esm/utils.js",
+      "require": "./lib/cjs/utils.js",
+      "types": "./lib/types/utils.d.ts"
+    }
+  },
+  "license": "Unlicense",
+  "dependencies": {
+    "@noble/ciphers": "2.1.1",
+    "@noble/curves": "2.0.1",
+    "@noble/hashes": "2.0.1",
+    "@scure/base": "2.0.0",
+    "@scure/bip32": "2.0.1",
+    "@scure/bip39": "2.0.1",
+    "nostr-wasm": "0.1.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "decentralization",
+    "social",
+    "censorship-resistance",
+    "client",
+    "nostr"
+  ],
+  "devDependencies": {
+    "@types/node": "^18.13.0",
+    "@types/node-fetch": "^2.6.3",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/parser": "^6.5.0",
+    "bun-types": "^1.0.18",
+    "esbuild": "0.16.9",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.0.0",
+    "events": "^3.3.0",
+    "mitata": "^0.1.6",
+    "mock-socket": "^9.3.1",
+    "node-fetch": "^2.6.9",
+    "prettier": "^3.0.3",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "prepublish": "just build"
+  }
+}

package/node_modules/nostr-wasm/README.md

@@ -0,0 +1,91 @@
+# nostr-wasm
+
+Nostr signature stuff in WASM based on libsecp256k1.
+
+## Install
+
+```sh
+yarn install
+```
+
+## Demo
+
+A demo application using this package is available at https://nostr-wasm-demo.pages.dev/.
+
+## Usage
+
+First, choose which import method suites your needs:
+
+#### Default
+
+Import with the WASM binary preloaded and uncompressed. No need to perform `fetch`, but bundle will be larger (+332 KiB).
+
+```ts
+import {initNostrWasm} from 'nostr-wasm'
+const nw = await initNostrWasm()
+```
+
+#### Compressed
+
+Import with the WASM binary preloaded and gzipped (requires access to `globalThis.DecompressionSteam`). No need to perform `fetch`, but bundle will be still be a bit larger (+175 KiB).
+
+```ts
+import {initNostrWasm} from 'nostr-wasm/gzipped'
+const nw = await initNostrWasm()
+```
+
+#### Headless
+
+Import without the WASM binary. Produces the smallest bundle size but requires fetching the binary yourself.
+
+```ts
+import {NostrWasm} from 'nostr-wasm/headless'
+
+// provide the binary (the constructor also accepts raw bytes)
+const nw = await NostrWasm(await fetch('secp256k1.wasm'))
+```
+
+### Using the instance:
+
+```ts
+// generate a random private key
+const sec = nw.generateSecretKey()
+
+// get its corresponding public key
+const pubkey = nw.getPublicKey(sec)
+
+// finalize a nostr event in-place, filling it with id, pubkey and sig
+nw.finalizeEvent(event, sec)
+
+// verify a nostr event checking its id and its signature against the given pubkey
+try {
+  nw.verifyEvent(event)
+} catch (err) {
+  console.log(err)
+}
+```
+
+Caller is responsible for zero-ing out private keys in the Uint8Array it passes. Library only zeroes out the bytes in the copies it makes.
+
+## Is libsecp256k1 modified?
+
+No, the library is imported as a git submodule directly from upstream.
+
+## Building from source
+
+Prerequisites:
+
+- [Podman](https://podman.io/)
+- [Bun](https://bun.sh/)
+- [Just](https://just.systems/)
+
+```sh
+git clone --recurse-submodules https://github.com/fiatjaf/nostr-wasm
+cd nostr-wasm
+bun install
+just
+```
+
+The WASM binary will be output to `public/out/secp256k1.wasm`.
+
+The Emscripten-generated js file at `public/out/secp256k1.js` is not needed for production if you are using the provided wrapper.

package/node_modules/nostr-wasm/dist/api/emsimp.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="web" />
+import type { ImportMapper } from 'src/types';
+export declare const emsimp: (f_map_imports: ImportMapper, label: string) => readonly [WebAssembly.Imports, (d_memory: WebAssembly.Memory) => readonly [ArrayBuffer, Uint8Array, Uint32Array]];

package/node_modules/nostr-wasm/dist/api/nostr.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="web" />
+/// <reference types="node" />
+type Event = {
+    id: string;
+    pubkey: string;
+    sig: string;
+    content: string;
+    kind: number;
+    created_at: number;
+    tags: string[][];
+};
+export interface Nostr {
+    /**
+     * Generates a new private key using crypto secure random bytes and without modulo bias
+     * @returns a new private key (32 bytes)
+     */
+    generateSecretKey(): Uint8Array;
+    /**
+     * Computes the public key for a given private key
+     * @param seckey - the private key (32 bytes)
+     * @returns the public key (32 bytes)
+     */
+    getPublicKey(seckey: Uint8Array): Uint8Array;
+    /**
+     * Fills in an event object with pubkey, id and sig.
+     * @param event - the Nostr event object
+     * @param seckey - the private key
+     * @param entropy - optional entropy to use
+     */
+    finalizeEvent(event: Event, seckey: Uint8Array, ent?: Uint8Array): void;
+    /**
+     * Verifies if an event's .id property is correct and that the .sig is valid
+     * @param event - the Nostr event object
+     * @throws an error with a .message if the event is not valid for any reason
+     */
+    verifyEvent(event: Event): void;
+}
+/**
+ * Creates a new instance of the secp256k1 WASM and returns the Nostr wrapper
+ * @param z_src - a Response containing the WASM binary, a Promise that resolves to one,
+ * 	or the raw bytes to the WASM binary as a {@link BufferSource}
+ * @returns the wrapper API
+ */
+export declare const NostrWasm: (z_src: Promise<Response> | Response | BufferSource) => Promise<Nostr>;
+export {};

package/node_modules/nostr-wasm/dist/api/secp256k1-types.d.ts

@@ -0,0 +1,124 @@
+import type { WasmExportsExtension } from '../gen/wasm.js';
+import type { Pointer } from '../types.js';
+export type PointerContext = Pointer<'context'>;
+export type PointerSeed = Pointer<'seed'>;
+export type PointerXOnlyKey = Pointer<'xonly_key'>;
+export type PointerKeypair = Pointer<'keypair'>;
+export type PointerSig = Pointer<'signature'>;
+export type PointerSha256 = Pointer<'sha256'>;
+export declare const enum ByteLens {
+    PRIVATE_KEY = 32,
+    KEYPAIR_LIB = 96,
+    XONLY_KEY_LIB = 64,
+    BIP340_SIG = 64,// secp256k1_bip340_signature: char [64];
+    XONLY_PUBKEY = 32,// serialized
+    MSG_HASH = 32,
+    NONCE_ENTROPY = 32,
+    SHA256_LIB = 104
+}
+export declare const enum Flags {
+    CONTEXT_NONE = 1,
+    CONTEXT_VERIFY = 257,
+    CONTEXT_SIGN = 513,
+    CONTEXT_DECLASSIFY = 1025
+}
+export declare const enum BinaryResult {
+    SUCCESS = 1,
+    FAILURE = 0
+}
+export interface Secp256k1WasmCore extends WasmExportsExtension {
+    /** Create a secp256k1 context object (in dynamically allocated memory).
+     *
+     *  This function uses malloc to allocate memory. It is guaranteed that malloc is
+     *  called at most once for every call of this function. If you need to avoid dynamic
+     *  memory allocation entirely, see secp256k1_context_static and the functions in
+     *  secp256k1_preallocated.h.
+     *
+     *  Returns: a newly created context object.
+     *  In:      flags: Always set to SECP256K1_CONTEXT_NONE (see below).
+     */
+    context_create(xm_flags: Flags): PointerContext;
+    /** Compute the keypair for a secret key.
+     *
+     *  Returns: 1: secret was valid, keypair is ready to use
+     *           0: secret was invalid, try again with a different secret
+     *  Args:    ctx: pointer to a context object, initialized for signing.
+     *  Out: keypair: pointer to the created keypair.
+     *  In:   seckey: pointer to a 32-byte secret key.
+     */
+    keypair_create(ctx: PointerContext, keypair: PointerKeypair, secret: Pointer<32>): BinaryResult;
+    /** Get the x-only public key from a keypair.
+     *
+     *  This is the same as calling secp256k1_keypair_pub and then
+     *  secp256k1_xonly_pubkey_from_pubkey.
+     *
+     *  Returns: 1 always.
+     *  Args:   ctx: pointer to a context object.
+     *  Out: pubkey: pointer to an xonly_pubkey object. If 1 is returned, it is set
+     *               to the keypair public key after converting it to an
+     *               xonly_pubkey. If not, it's set to an invalid value.
+     *    pk_parity: Ignored if NULL. Otherwise, pointer to an integer that will be set to the
+     *               pk_parity argument of secp256k1_xonly_pubkey_from_pubkey.
+     *  In: keypair: pointer to a keypair.
+     */
+    keypair_xonly_pub(ctx: PointerContext, pubkey: PointerXOnlyKey, pk_parity: Pointer | null, keypair: PointerKeypair): BinaryResult;
+    /** Parse a 32-byte sequence into a xonly_pubkey object.
+     *
+     *  Returns: 1 if the public key was fully valid.
+     *           0 if the public key could not be parsed or is invalid.
+     *
+     *  Args:   ctx: a secp256k1 context object.
+     *  Out: pubkey: pointer to a pubkey object. If 1 is returned, it is set to a
+     *               parsed version of input. If not, it's set to an invalid value.
+     *  In: input32: pointer to a serialized xonly_pubkey.
+     */
+    xonly_pubkey_parse(ctx: PointerContext, pubkey: PointerXOnlyKey, input32: Pointer<32>): BinaryResult;
+    /** Serialize an xonly_pubkey object into a 32-byte sequence.
+     *
+     *  Returns: 1 always.
+     *
+     *  Args:     ctx: a secp256k1 context object.
+     *  Out: output32: a pointer to a 32-byte array to place the serialized key in.
+     *  In:    pubkey: a pointer to a secp256k1_xonly_pubkey containing an initialized public key.
+     */
+    xonly_pubkey_serialize(ctx: PointerContext, output32: Pointer<32>, pubkey: PointerXOnlyKey): BinaryResult;
+    /** Create a Schnorr signature.
+     *
+     *  Does _not_ strictly follow BIP-340 because it does not verify the resulting
+     *  signature. Instead, you can manually use secp256k1_schnorrsig_verify and
+     *  abort if it fails.
+     *
+     *  This function only signs 32-byte messages. If you have messages of a
+     *  different size (or the same size but without a context-specific tag
+     *  prefix), it is recommended to create a 32-byte message hash with
+     *  secp256k1_tagged_sha256 and then sign the hash. Tagged hashing allows
+     *  providing an context-specific tag for domain separation. This prevents
+     *  signatures from being valid in multiple contexts by accident.
+     *
+     *  Returns 1 on success, 0 on failure.
+     *  Args:    ctx: pointer to a context object, initialized for signing.
+     *  Out:   sig64: pointer to a 64-byte array to store the serialized signature.
+     *  In:    msg32: the 32-byte message being signed.
+     *       keypair: pointer to an initialized keypair.
+     *    aux_rand32: 32 bytes of fresh randomness. While recommended to provide
+     *                this, it is only supplemental to security and can be NULL. A
+     *                NULL argument is treated the same as an all-zero one. See
+     *                BIP-340 "Default Signing" for a full explanation of this
+     *                argument and for guidance if randomness is expensive.
+     */
+    schnorrsig_sign32(ctx: PointerContext, sig64: PointerSig, msg32: Pointer<32>, keypair: PointerKeypair, aux_rand32: Pointer<32>): BinaryResult;
+    /** Verify a Schnorr signature.
+     *
+     *  Returns: 1: correct signature
+     *           0: incorrect signature
+     *  Args:    ctx: a secp256k1 context object, initialized for verification.
+     *  In:    sig64: pointer to the 64-byte signature to verify.
+     *           msg: the message being verified. Can only be NULL if msglen is 0.
+     *        msglen: length of the message
+     *        pubkey: pointer to an x-only public key to verify with (cannot be NULL)
+     */
+    schnorrsig_verify(ctx: PointerContext, sig64: PointerSig, msg32: Pointer<32>, msglen: number, pubkey: PointerXOnlyKey): BinaryResult;
+    sha256_initialize(hash: PointerSha256): void;
+    sha256_write(hash: PointerSha256, data: Pointer<number>, size: number): void;
+    sha256_finalize(hash: PointerSha256, out32: Pointer<32>): void;
+}