@openclaw/nostr 2026.5.20 → 2026.5.22

package/node_modules/nostr-wasm/dist/nostr.js

@@ -0,0 +1,248 @@
+function defineWasmEnv(label) {
+    label += ': ';
+    let AB_HEAP;
+    let ATU8_HEAP;
+    let ATU32_HEAP;
+    // eslint-disable-next-line no-console
+    const console_out = (s_channel, s_out) => console[s_channel](label + s_out.replace(/\0/g, '\n'));
+    let s_error = '';
+    // for converting bytes to text
+    const utf8 = new TextDecoder();
+    const h_fds = {
+        // stdout
+        1(s_out) {
+            console_out('debug', s_out);
+        },
+        // stderr
+        2(s_out) {
+            console_out('error', (s_error = s_out));
+        }
+    };
+    const imports = {
+        abort() {
+            throw Error(label + (s_error || 'An unknown error occurred'));
+        },
+        memcpy: (ip_dst, ip_src, nb_size) => ATU8_HEAP.copyWithin(ip_dst, ip_src, ip_src + nb_size),
+        resize(w) {
+            throw Error(label + `Out of memory (resizing ${w})`);
+        },
+        write(i_fd, ip_iov, nl_iovs, ip_written) {
+            // output string
+            let s_out = '';
+            // track number of bytes read from buffers
+            let cb_read = 0;
+            // each pending iov
+            for (let i_iov = 0; i_iov < nl_iovs; i_iov++) {
+                // start of buffer in memory
+                const ip_start = ATU32_HEAP[ip_iov >> 2];
+                // size of buffer
+                const nb_len = ATU32_HEAP[(ip_iov + 4) >> 2];
+                ip_iov += 8;
+                // extract text from buffer
+                s_out += utf8.decode(ATU8_HEAP.subarray(ip_start, ip_start + nb_len));
+                // update number of bytes read
+                cb_read += nb_len;
+            }
+            // route to fd
+            if (h_fds[i_fd]) {
+                h_fds[i_fd](s_out);
+            }
+            else {
+                // no fd found
+                throw new Error(`libsecp256k1 tried writing to non-open file descriptor: ${i_fd}\n${s_out}`);
+            }
+            // write bytes read
+            ATU32_HEAP[ip_written >> 2] = cb_read;
+            // no error
+            return 0;
+        }
+    };
+    return [
+        imports,
+        (d_memory) => [
+            (AB_HEAP = d_memory.buffer),
+            (ATU8_HEAP = new Uint8Array(AB_HEAP)),
+            (ATU32_HEAP = new Uint32Array(AB_HEAP))
+        ]
+    ];
+}
+
+/*
+* ================================
+*     GENERATED FILE WARNING
+* Do not edit this file manually.
+* ================================
+*/
+const map_wasm_imports = (g_imports) => ({
+    a: {
+        a: g_imports.abort,
+        f: g_imports.memcpy,
+        d: g_imports.resize,
+        e: () => 52, // _fd_close,
+        c: () => 70, // _fd_seek,
+        b: g_imports.write,
+    },
+});
+const map_wasm_exports = (g_exports) => ({
+    malloc: g_exports['i'],
+    free: g_exports['j'],
+    sha256_initialize: g_exports['l'],
+    sha256_write: g_exports['m'],
+    sha256_finalize: g_exports['n'],
+    context_create: g_exports['o'],
+    xonly_pubkey_parse: g_exports['p'],
+    xonly_pubkey_serialize: g_exports['q'],
+    keypair_create: g_exports['r'],
+    keypair_xonly_pub: g_exports['s'],
+    schnorrsig_sign32: g_exports['t'],
+    schnorrsig_verify: g_exports['u'],
+    sbrk: g_exports['sbrk'],
+    memory: g_exports['g'],
+    init: () => g_exports['h'](),
+});
+
+/**
+ * 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
+ */
+const NostrWasm = async (z_src) => {
+    // prepare the runtime
+    const [defs, f_bind_heap] = defineWasmEnv('nostr-wasm');
+    const g_imports = map_wasm_imports(defs);
+    // prep the wasm module
+    let d_wasm;
+    // instantiate wasm binary by streaming the response bytes
+    if (z_src instanceof Response || z_src instanceof Promise) {
+        d_wasm = await WebAssembly.instantiateStreaming(z_src, g_imports);
+    }
+    else {
+        // instantiate using raw binary
+        d_wasm = await WebAssembly.instantiate(z_src, g_imports);
+    }
+    // create the exports struct
+    const g_wasm = map_wasm_exports(d_wasm.instance.exports);
+    // bind the heap and ref its view(s)
+    const [, ATU8_HEAP] = f_bind_heap(g_wasm.memory);
+    // call into the wasm module's init method
+    g_wasm.init();
+    const ip_sk = g_wasm.malloc(32 /* ByteLens.PRIVATE_KEY */);
+    const ip_ent = g_wasm.malloc(32 /* ByteLens.NONCE_ENTROPY */);
+    const ip_msg_hash = g_wasm.malloc(32 /* ByteLens.MSG_HASH */);
+    // scratch spaces
+    const ip_pubkey_scratch = g_wasm.malloc(32 /* ByteLens.XONLY_PUBKEY */);
+    const ip_sig_scratch = g_wasm.malloc(64 /* ByteLens.BIP340_SIG */);
+    // library handle: secp256k1_keypair;
+    const ip_keypair = g_wasm.malloc(96 /* ByteLens.KEYPAIR_LIB */);
+    // library handle: secp256k1_xonly_pubkey;
+    const ip_xonly_pubkey = g_wasm.malloc(64 /* ByteLens.XONLY_KEY_LIB */);
+    // library handle: secp256k1_sha256;
+    const ip_sha256 = g_wasm.malloc(104 /* ByteLens.SHA256_LIB */);
+    // create a reusable context
+    const ip_ctx = g_wasm.context_create(513 /* Flags.CONTEXT_SIGN */ | 257 /* Flags.CONTEXT_VERIFY */);
+    // an encoder for hashing strings
+    const utf8 = new TextEncoder();
+    /**
+     * Puts the given private key into program memory, runs the given callback, then zeroes out the key
+     * @param atu8_sk - the private key
+     * @param f_use - callback to use the key
+     * @returns whatever the callback returns
+     */
+    const with_keypair = (atu8_sk, f_use) => {
+        // prep callback return
+        let w_return;
+        // in case of any exception..
+        try {
+            // copy input bytes into place
+            ATU8_HEAP.set(atu8_sk, ip_sk);
+            // instantiate keypair
+            g_wasm.keypair_create(ip_ctx, ip_keypair, ip_sk);
+            // use private key
+            w_return = f_use();
+        }
+        finally {
+            // zero-out private key and keypair
+            ATU8_HEAP.fill(1, ip_sk, ip_sk + 32 /* ByteLens.PRIVATE_KEY */);
+            ATU8_HEAP.fill(2, ip_keypair, ip_keypair + 96 /* ByteLens.KEYPAIR_LIB */);
+        }
+        // forward result
+        return w_return;
+    };
+    const compute_event_id = (event) => {
+        const message = utf8.encode(`[0,"${event.pubkey}",${event.created_at},${event.kind},${JSON.stringify(event.tags)},${JSON.stringify(event.content)}]`);
+        const ip_message = g_wasm.malloc(message.length);
+        ATU8_HEAP.set(message, ip_message);
+        g_wasm.sha256_initialize(ip_sha256);
+        g_wasm.sha256_write(ip_sha256, ip_message, message.length);
+        g_wasm.sha256_finalize(ip_sha256, ip_msg_hash);
+        g_wasm.free(ip_message);
+        return ATU8_HEAP.slice(ip_msg_hash, ip_msg_hash + 32 /* ByteLens.MSG_HASH */);
+    };
+    return {
+        generateSecretKey: () => crypto.getRandomValues(new Uint8Array(32 /* ByteLens.PRIVATE_KEY */)),
+        getPublicKey(sk) {
+            if (1 /* BinaryResult.SUCCESS */ !==
+                with_keypair(sk, () => g_wasm.keypair_xonly_pub(ip_ctx, ip_xonly_pubkey, null, ip_keypair))) {
+                throw Error('failed to get pubkey from keypair');
+            }
+            // serialize the public key
+            g_wasm.xonly_pubkey_serialize(ip_ctx, ip_pubkey_scratch, ip_xonly_pubkey);
+            // extract result
+            return ATU8_HEAP.slice(ip_pubkey_scratch, ip_pubkey_scratch + 32 /* ByteLens.XONLY_PUBKEY */);
+        },
+        finalizeEvent(event, seckey, ent) {
+            with_keypair(seckey, () => {
+                // get public key (as in getPublicKey function above)
+                g_wasm.keypair_xonly_pub(ip_ctx, ip_xonly_pubkey, null, ip_keypair);
+                g_wasm.xonly_pubkey_serialize(ip_ctx, ip_pubkey_scratch, ip_xonly_pubkey);
+                const pubkey = ATU8_HEAP.slice(ip_pubkey_scratch, ip_pubkey_scratch + 32 /* ByteLens.XONLY_PUBKEY */);
+                event.pubkey = toHex(pubkey);
+                // compute event id
+                event.id = toHex(compute_event_id(event));
+                // copy entropy bytes into place, if they are provided
+                if (!ent && crypto.getRandomValues) {
+                    ATU8_HEAP.set(crypto.getRandomValues(new Uint8Array(32)), ip_ent);
+                }
+                // perform signature (ip_msg_hash is already set from procedure above)
+                if (1 /* BinaryResult.SUCCESS */ !==
+                    g_wasm.schnorrsig_sign32(ip_ctx, ip_sig_scratch, ip_msg_hash, ip_keypair, ip_ent)) {
+                    throw Error('failed to sign');
+                }
+            });
+            const sig = ATU8_HEAP.slice(ip_sig_scratch, ip_sig_scratch + 64 /* ByteLens.BIP340_SIG */);
+            event.sig = toHex(sig);
+        },
+        verifyEvent(event) {
+            const id = fromHex(event.id);
+            // check event hash
+            const computed = compute_event_id(event);
+            for (let i = 0; i < id.length; i++) {
+                if (id[i] !== computed[i])
+                    throw Error('id is invalid');
+            }
+            // copy event data into place
+            ATU8_HEAP.set(fromHex(event.sig), ip_sig_scratch);
+            ATU8_HEAP.set(fromHex(event.id), ip_msg_hash);
+            ATU8_HEAP.set(fromHex(event.pubkey), ip_pubkey_scratch);
+            // parse the public key
+            if (1 /* BinaryResult.SUCCESS */ !==
+                g_wasm.xonly_pubkey_parse(ip_ctx, ip_xonly_pubkey, ip_pubkey_scratch)) {
+                throw Error('pubkey is invalid');
+            }
+            // verify the signature
+            if (1 /* BinaryResult.SUCCESS */ !==
+                g_wasm.schnorrsig_verify(ip_ctx, ip_sig_scratch, ip_msg_hash, 32 /* ByteLens.MSG_HASH */, ip_xonly_pubkey)) {
+                throw Error('signature is invalid');
+            }
+        }
+    };
+};
+function toHex(bytes) {
+    return bytes.reduce((hex, byte) => hex + byte.toString(16).padStart(2, '0'), '');
+}
+function fromHex(hex) {
+    return new Uint8Array(hex.length / 2).map((_, i) => parseInt(hex.slice(i * 2, i * 2 + 2), 16));
+}
+
+export { NostrWasm as N };

package/node_modules/nostr-wasm/dist/secp256k1.js

@@ -0,0 +1,230 @@
+const emsimp = (f_map_imports, s_tag) => {
+    s_tag += ': ';
+    let AB_HEAP;
+    let ATU8_HEAP;
+    let ATU32_HEAP;
+    // eslint-disable-next-line no-console
+    const console_out = (s_channel, s_out) => console[s_channel](s_tag + s_out.replace(/\0/g, '\n'));
+    let s_error = '';
+    // for converting bytes to text
+    const utf8 = new TextDecoder();
+    const h_fds = {
+        // stdout
+        1(s_out) {
+            console_out('debug', s_out);
+        },
+        // stderr
+        2(s_out) {
+            console_out('error', (s_error = s_out));
+        }
+    };
+    const g_imports = f_map_imports({
+        abort() {
+            throw Error(s_tag + (s_error || 'An unknown error occurred'));
+        },
+        memcpy: (ip_dst, ip_src, nb_size) => ATU8_HEAP.copyWithin(ip_dst, ip_src, ip_src + nb_size),
+        resize(_) {
+            throw Error(s_tag + 'Out of memory');
+        },
+        write(i_fd, ip_iov, nl_iovs, ip_written) {
+            // output string
+            let s_out = '';
+            // track number of bytes read from buffers
+            let cb_read = 0;
+            // each pending iov
+            for (let i_iov = 0; i_iov < nl_iovs; i_iov++) {
+                // start of buffer in memory
+                const ip_start = ATU32_HEAP[ip_iov >> 2];
+                // size of buffer
+                const nb_len = ATU32_HEAP[(ip_iov + 4) >> 2];
+                ip_iov += 8;
+                // extract text from buffer
+                s_out += utf8.decode(ATU8_HEAP.subarray(ip_start, ip_start + nb_len));
+                // update number of bytes read
+                cb_read += nb_len;
+            }
+            // route to fd
+            if (h_fds[i_fd]) {
+                h_fds[i_fd](s_out);
+            }
+            else {
+                // no fd found
+                throw new Error(`libsecp256k1 tried writing to non-open file descriptor: ${i_fd}\n${s_out}`);
+            }
+            // write bytes read
+            ATU32_HEAP[ip_written >> 2] = cb_read;
+            // no error
+            return 0;
+        }
+    });
+    return [
+        g_imports,
+        (d_memory) => [
+            (AB_HEAP = d_memory.buffer),
+            (ATU8_HEAP = new Uint8Array(AB_HEAP)),
+            (ATU32_HEAP = new Uint32Array(AB_HEAP))
+        ]
+    ];
+};
+
+/*
+* ================================
+*     GENERATED FILE WARNING
+* Do not edit this file manually.
+* ================================
+*/
+const map_wasm_imports = (g_imports) => ({
+    a: {
+        a: g_imports.abort,
+        f: g_imports.memcpy,
+        d: g_imports.resize,
+        e: () => 52, // _fd_close,
+        c: () => 70, // _fd_seek,
+        b: g_imports.write,
+    },
+});
+const map_wasm_exports = (g_exports) => ({
+    malloc: g_exports['i'],
+    free: g_exports['j'],
+    sha256_initialize: g_exports['l'],
+    sha256_write: g_exports['m'],
+    sha256_finalize: g_exports['n'],
+    context_create: g_exports['o'],
+    xonly_pubkey_parse: g_exports['p'],
+    xonly_pubkey_serialize: g_exports['q'],
+    keypair_create: g_exports['r'],
+    keypair_xonly_pub: g_exports['s'],
+    schnorrsig_sign32: g_exports['t'],
+    schnorrsig_verify: g_exports['u'],
+    sbrk: g_exports['sbrk'],
+    memory: g_exports['g'],
+    init: () => g_exports['h'](),
+});
+
+const S_TAG_BIP340_VERIFY = 'BIP340 verify: ';
+const S_REASON_INVALID_SK = 'Invalid private key';
+const S_REASON_INVALID_PK = 'Invalid public key';
+/**
+ * Creates a new instance of the secp256k1 WASM and returns its ES 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
+ */
+const WasmSecp256k1 = async (z_src) => {
+    // prepare the runtime
+    const [g_imports, f_bind_heap] = emsimp(map_wasm_imports, 'wasm-secp256k1');
+    // prep the wasm module
+    let d_wasm;
+    // instantiate wasm binary by streaming the response bytes
+    if (z_src instanceof Response || z_src instanceof Promise) {
+        d_wasm = await WebAssembly.instantiateStreaming(z_src, g_imports);
+    }
+    else {
+        // instantiate using raw binary
+        d_wasm = await WebAssembly.instantiate(z_src, g_imports);
+    }
+    // create the libsecp256k1 exports struct
+    const g_wasm = map_wasm_exports(d_wasm.instance.exports);
+    // bind the heap and ref its view(s)
+    const [, ATU8_HEAP] = f_bind_heap(g_wasm.memory);
+    // call into the wasm module's init method
+    g_wasm.init();
+    const ip_sk = g_wasm.malloc(32 /* ByteLens.PRIVATE_KEY */);
+    const ip_ent = g_wasm.malloc(32 /* ByteLens.NONCE_ENTROPY */);
+    const ip_msg_hash = g_wasm.malloc(32 /* ByteLens.MSG_HASH */);
+    // scratch spaces
+    const ip_pubkey_scratch = g_wasm.malloc(32 /* ByteLens.XONLY_PUBKEY */);
+    const ip_sig_scratch = g_wasm.malloc(64 /* ByteLens.BIP340_SIG */);
+    // library handle: secp256k1_keypair;
+    const ip_keypair = g_wasm.malloc(96 /* ByteLens.KEYPAIR_LIB */);
+    // library handle: secp256k1_xonly_pubkey;
+    const ip_xonly_pubkey = g_wasm.malloc(64 /* ByteLens.XONLY_KEY_LIB */);
+    // library handle: secp256k1_sha256;
+    const ip_sha256 = g_wasm.malloc(104 /* ByteLens.SHA256_LIB */);
+    // create a reusable context
+    const ip_ctx = g_wasm.context_create(513 /* Flags.CONTEXT_SIGN */ | 257 /* Flags.CONTEXT_VERIFY */);
+    // an encoder for hashing strings
+    const utf8 = new TextEncoder();
+    /**
+     * Puts the given private key into program memory, runs the given callback, then zeroes out the key
+     * @param atu8_sk - the private key
+     * @param f_use - callback to use the key
+     * @returns whatever the callback returns
+     */
+    const with_keypair = (atu8_sk, f_use) => {
+        // prep callback return
+        let w_return;
+        // in case of any exception..
+        try {
+            // copy input bytes into place
+            ATU8_HEAP.set(atu8_sk, ip_sk);
+            // instantiate keypair
+            g_wasm.keypair_create(ip_ctx, ip_keypair, ip_sk);
+            // use private key
+            w_return = f_use();
+        }
+        finally {
+            // zero-out private key and keypair
+            ATU8_HEAP.fill(1, ip_sk, ip_sk + 32 /* ByteLens.PRIVATE_KEY */);
+            ATU8_HEAP.fill(2, ip_keypair, ip_keypair + 96 /* ByteLens.KEYPAIR_LIB */);
+        }
+        // forward result
+        return w_return;
+    };
+    return {
+        gen_secret_key: () => crypto.getRandomValues(new Uint8Array(32 /* ByteLens.PRIVATE_KEY */)),
+        get_public_key(atu8_sk) {
+            // while using the private key, compute its corresponding public key; from the docs:
+            if (1 /* BinaryResult.SUCCESS */ !==
+                with_keypair(atu8_sk, () => g_wasm.keypair_xonly_pub(ip_ctx, ip_xonly_pubkey, null, ip_keypair))) {
+                throw Error('sk_to_pk: ' + S_REASON_INVALID_SK);
+            }
+            // serialize the public key
+            g_wasm.xonly_pubkey_serialize(ip_ctx, ip_pubkey_scratch, ip_xonly_pubkey);
+            // extract result
+            return ATU8_HEAP.slice(ip_pubkey_scratch, ip_pubkey_scratch + 32 /* ByteLens.XONLY_PUBKEY */);
+        },
+        sign(atu8_sk, atu8_hash, atu8_ent) {
+            // copy message hash bytes into place
+            ATU8_HEAP.set(atu8_hash, ip_msg_hash);
+            // copy entropy bytes into place
+            if (!atu8_ent && crypto.getRandomValues) {
+                ATU8_HEAP.set(crypto.getRandomValues(new Uint8Array(32)), ip_ent);
+            }
+            // while using the private key, sign the given message hash
+            if (1 /* BinaryResult.SUCCESS */ !==
+                with_keypair(atu8_sk, () => g_wasm.schnorrsig_sign32(ip_ctx, ip_sig_scratch, ip_msg_hash, ip_keypair, ip_ent))) {
+                throw Error('BIP-340 sign: ' + S_REASON_INVALID_SK);
+            }
+            // return serialized signature
+            return ATU8_HEAP.slice(ip_sig_scratch, ip_sig_scratch + 64 /* ByteLens.BIP340_SIG */);
+        },
+        verify(atu8_signature, atu8_hash, atu8_pk) {
+            // copy signature bytes into place
+            ATU8_HEAP.set(atu8_signature, ip_sig_scratch);
+            // copy message hash bytes into place
+            ATU8_HEAP.set(atu8_hash, ip_msg_hash);
+            // copy pubkey bytes into place
+            ATU8_HEAP.set(atu8_pk, ip_pubkey_scratch);
+            // parse the public key
+            if (1 /* BinaryResult.SUCCESS */ !==
+                g_wasm.xonly_pubkey_parse(ip_ctx, ip_xonly_pubkey, ip_pubkey_scratch)) {
+                throw Error(S_TAG_BIP340_VERIFY + S_REASON_INVALID_PK);
+            }
+            // verify the signature
+            return (1 /* BinaryResult.SUCCESS */ ===
+                g_wasm.schnorrsig_verify(ip_ctx, ip_sig_scratch, ip_msg_hash, 32 /* ByteLens.MSG_HASH */, ip_xonly_pubkey));
+        },
+        sha256(message) {
+            const ip_message = g_wasm.malloc(message.length);
+            const data = utf8.encode(message);
+            ATU8_HEAP.set(data, ip_message);
+            g_wasm.sha256_initialize(ip_sha256);
+            g_wasm.sha256_write(ip_sha256, ip_message, message.length);
+            g_wasm.sha256_finalize(ip_sha256, ip_msg_hash);
+            return ATU8_HEAP.slice(ip_msg_hash, ip_msg_hash + 32 /* ByteLens.MSG_HASH */);
+        }
+    };
+};
+
+export { WasmSecp256k1 as W };

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

@@ -0,0 +1,22 @@
+/// <reference types="web" />
+export type Pointer<w_subtype = unknown> = number & {
+    POINTER_TYPE: w_subtype;
+};
+export type ByteSize = number;
+export type ByteDelta = number;
+export type ByteOffset = number;
+export type FileDescriptor = number;
+export type SeekWhence = number;
+export interface WasmImports {
+    abort: () => void;
+    memcpy: <nb_size extends ByteSize>(ip_dst: Pointer<nb_size>, ip_src: Pointer<nb_size>, nb_size: nb_size) => Uint8Array;
+    resize: (nb_size: ByteSize) => void;
+    write: (i_fd: FileDescriptor, ip_iov: Pointer<number>, nl_iovs: number, ip_written: Pointer<number>) => 0;
+}
+export interface WasmExports {
+    malloc: <w_pointer_type extends Pointer, nb_size extends ByteSize = ByteSize>(nb_size: nb_size) => Pointer extends w_pointer_type ? Pointer<nb_size> : w_pointer_type;
+    free: (ip_ptr: Pointer) => void;
+    sbrk: (nb_change: ByteDelta) => Pointer;
+    memory: WebAssembly.Memory;
+    init: VoidFunction;
+}

package/node_modules/nostr-wasm/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "nostr-wasm",
+  "description": "nostr stuff in wasm",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/main.js",
+  "files": [
+    "dist/",
+    "public/"
+  ],
+  "exports": {
+    ".": "./dist/main.js",
+    "./headless": "./dist/headless.js",
+    "./gzipped": "./dist/gzipped.js"
+  },
+  "author": "fiatjaf <fiatjaf@gmail.com>",
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "@blake.regalia/tsconfig": "^0.1.2",
+    "@rollup/plugin-typescript": "^11.1.5",
+    "@rollup/plugin-wasm": "^6.2.2",
+    "@rollup/pluginutils": "^5.0.5",
+    "@types/node": "^20.8.10",
+    "@types/web": "^0.0.119",
+    "@typescript-eslint/eslint-plugin": "^6.13.2",
+    "@typescript-eslint/parser": "^6.13.2",
+    "acorn": "^8.11.2",
+    "eslint": "^8.52.0",
+    "eslint-plugin-unused-imports": "^3.0.0",
+    "rollup": "^4.2.0",
+    "typescript": "^5.2.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/nostr-wasm/public/out/secp256k1.js

@@ -0,0 +1 @@
+var Module=globalThis.Module||{};var ENVIRONMENT_IS_NODE=typeof process=="object";if(ENVIRONMENT_IS_NODE){var fs=require("fs");Module["wasm"]=fs.readFileSync(__dirname+"/secp256k1.wasm")}var out=text=>console.log(text);var err=text=>console.error(text);function ready(){}function abort(what){throw what}var HEAP8,HEAP16,HEAP32,HEAPU8,HEAPU16,HEAPU32,HEAPF32,HEAPF64,wasmMemory;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b)}var noExitRuntime=Module["noExitRuntime"]||true;var _abort=()=>{abort("")};var _emscripten_memcpy_js=(dest,src,num)=>HEAPU8.copyWithin(dest,src,src+num);var abortOnCannotGrowMemory=requestedSize=>{abort("OOM")};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;abortOnCannotGrowMemory(requestedSize)};var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;var UTF8ArrayToString=(heapOrArray,idx,maxBytesToRead)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var SYSCALLS={varargs:undefined,get(){var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret},getp(){return SYSCALLS.get()},getStr(ptr){var ret=UTF8ToString(ptr);return ret}};var _fd_close=fd=>52;var convertI32PairToI53Checked=(lo,hi)=>hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN;function _fd_seek(fd,offset_low,offset_high,whence,newOffset){var offset=convertI32PairToI53Checked(offset_low,offset_high);return 70}var printCharBuffers=[null,[],[]];var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer,0));buffer.length=0}else{buffer.push(curr)}};var _fd_write=(fd,iov,iovcnt,pnum)=>{var num=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j<len;j++){printChar(fd,HEAPU8[ptr+j])}num+=len}HEAPU32[pnum>>2]=num;return 0};var wasmImports={a:_abort,f:_emscripten_memcpy_js,d:_emscripten_resize_heap,e:_fd_close,c:_fd_seek,b:_fd_write};function initRuntime(wasmExports){wasmExports["h"]()}var imports={"a":wasmImports};var _malloc,_free,_secp256k1_sha256_initialize,_secp256k1_sha256_write,_secp256k1_sha256_finalize,_secp256k1_context_create,_secp256k1_xonly_pubkey_parse,_secp256k1_xonly_pubkey_serialize,_secp256k1_keypair_create,_secp256k1_keypair_xonly_pub,_secp256k1_schnorrsig_sign32,_secp256k1_schnorrsig_verify,_sbrk;WebAssembly.instantiate(Module["wasm"],imports).then(output=>{var wasmExports=output.instance.exports;_malloc=wasmExports["i"];_free=wasmExports["j"];_secp256k1_sha256_initialize=wasmExports["l"];_secp256k1_sha256_write=wasmExports["m"];_secp256k1_sha256_finalize=wasmExports["n"];_secp256k1_context_create=wasmExports["o"];_secp256k1_xonly_pubkey_parse=wasmExports["p"];_secp256k1_xonly_pubkey_serialize=wasmExports["q"];_secp256k1_keypair_create=wasmExports["r"];_secp256k1_keypair_xonly_pub=wasmExports["s"];_secp256k1_schnorrsig_sign32=wasmExports["t"];_secp256k1_schnorrsig_verify=wasmExports["u"];_sbrk=wasmExports["sbrk"];wasmMemory=wasmExports["g"];updateMemoryViews();initRuntime(wasmExports);ready()});

package/node_modules/zod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.