@starknetfoundation/krusty-kms-wasm 0.4.5 → 0.5.0

package/krusty_kms_wasm.js

@@ -1212,7 +1212,15 @@ export class WasmFundProofResult {
 if (Symbol.dispose) WasmFundProofResult.prototype[Symbol.dispose] = WasmFundProofResult.prototype.free;
 
 /**
- * Keypair for Tongo operations.
+ * Keypair for Tongo / Starknet operations.
+ *
+ * # Security / threat model
+ *
+ * This type intentionally exposes `private_key` as a plain hex string for
+ * JS interop (signing, export, wallet recovery). That string lives in the
+ * JS heap and **cannot** be reliably wiped. Prefer companion public-only
+ * APIs (`derivePublicKey`, etc.) when private material is not required.
+ * Never `console.log` this value; `Debug` redacts the private key.
  */
 export class WasmKeypair {
     static __wrap(ptr) {
@@ -1233,7 +1241,10 @@ export class WasmKeypair {
         wasm.__wbg_wasmkeypair_free(ptr, 0);
     }
     /**
-     * Private key as hex string (0x-prefixed)
+     * Private key as hex string (0x-prefixed). Treat as secret.
+     *
+     * Omitted from default `Serialize` (use the wasm-bindgen getter for the
+     * intentional secret-returning API).
      * @returns {string}
      */
     get private_key() {
@@ -1281,7 +1292,10 @@ export class WasmKeypair {
         }
     }
     /**
-     * Private key as hex string (0x-prefixed)
+     * Private key as hex string (0x-prefixed). Treat as secret.
+     *
+     * Omitted from default `Serialize` (use the wasm-bindgen getter for the
+     * intentional secret-returning API).
      * @param {string} arg0
      */
     set private_key(arg0) {
@@ -1320,24 +1334,35 @@ export class WasmKeypair {
         const ptr2 = passStringToWasm0(public_key_y, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len2 = WASM_VECTOR_LEN;
         const ret = wasm.wasmkeypair_new(ptr0, len0, ptr1, len1, ptr2, len2);
-        this.__wbg_ptr = ret >>> 0;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         WasmKeypairFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Get the full public key as "0x{x}{y}" concatenated hex.
+     * Get the full public key as fixed-width `0x` + 128 hex digits (x||y).
+     *
+     * Compatible with `deserializePublicKey`.
      * @returns {string}
      */
     publicKeyHex() {
-        let deferred1_0;
-        let deferred1_1;
+        let deferred2_0;
+        let deferred2_1;
         try {
             const ret = wasm.wasmkeypair_publicKeyHex(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
 }
@@ -1348,6 +1373,12 @@ if (Symbol.dispose) WasmKeypair.prototype[Symbol.dispose] = WasmKeypair.prototyp
  *
  * Used for NIP-04/NIP-44 encrypted messaging.
  * Public key is x-only (32 bytes, BIP-340 format).
+ *
+ * # Security / threat model
+ *
+ * `private_key` is a plain hex string in the JS heap and cannot be reliably
+ * wiped. Prefer [`WasmNostrPublicKey`] / `deriveNostrPublicKey` when private
+ * material is not required. `Debug` redacts the private key.
  */
 export class WasmNostrKeypair {
     static __wrap(ptr) {
@@ -1368,7 +1399,10 @@ export class WasmNostrKeypair {
         wasm.__wbg_wasmnostrkeypair_free(ptr, 0);
     }
     /**
-     * Private key as hex string (64 hex chars, no 0x prefix)
+     * Private key as hex string (64 hex chars, no 0x prefix). Treat as secret.
+     *
+     * Omitted from default `Serialize` (use the wasm-bindgen getter for the
+     * intentional secret-returning API).
      * @returns {string}
      */
     get private_key() {
@@ -1400,7 +1434,10 @@ export class WasmNostrKeypair {
         }
     }
     /**
-     * Private key as hex string (64 hex chars, no 0x prefix)
+     * Private key as hex string (64 hex chars, no 0x prefix). Treat as secret.
+     *
+     * Omitted from default `Serialize` (use the wasm-bindgen getter for the
+     * intentional secret-returning API).
      * @param {string} arg0
      */
     set private_key(arg0) {
@@ -1434,6 +1471,66 @@ export class WasmNostrKeypair {
 }
 if (Symbol.dispose) WasmNostrKeypair.prototype[Symbol.dispose] = WasmNostrKeypair.prototype.free;
 
+/**
+ * Public-only Nostr key (x-only, BIP-340). No private key material.
+ */
+export class WasmNostrPublicKey {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmNostrPublicKey.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmNostrPublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmNostrPublicKeyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmnostrpublickey_free(ptr, 0);
+    }
+    /**
+     * Public key as x-only hex string (64 hex chars, no 0x prefix)
+     * @returns {string}
+     */
+    get public_key() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmnostrpublickey_public_key(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Public key as x-only hex string (64 hex chars, no 0x prefix)
+     * @param {string} arg0
+     */
+    set public_key(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmciphertext_l_x(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} public_key
+     */
+    constructor(public_key) {
+        const ptr0 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmnostrpublickey_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        WasmNostrPublicKeyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmNostrPublicKey.prototype[Symbol.dispose] = WasmNostrPublicKey.prototype.free;
+
 /**
  * Nostr BIP-340 Schnorr signature result.
  */
@@ -1595,6 +1692,125 @@ export class WasmPoint {
 }
 if (Symbol.dispose) WasmPoint.prototype[Symbol.dispose] = WasmPoint.prototype.free;
 
+/**
+ * Public-only Stark / Tongo key material (no private key).
+ *
+ * Prefer this over [`WasmKeypair`] when only the public key is needed
+ * (address derivation, display, API lookups). Both affine coordinates are
+ * populated; for x-only Stark keys use [`WasmStarkXOnlyPublicKey`].
+ */
+export class WasmPublicKey {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmPublicKey.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmPublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPublicKeyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpublickey_free(ptr, 0);
+    }
+    /**
+     * Public key X coordinate as hex string
+     * @returns {string}
+     */
+    get public_key_x() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmpublickey_public_key_x(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Public key Y coordinate as hex string
+     * @returns {string}
+     */
+    get public_key_y() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmpublickey_public_key_y(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Public key X coordinate as hex string
+     * @param {string} arg0
+     */
+    set public_key_x(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmciphertext_l_x(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Public key Y coordinate as hex string
+     * @param {string} arg0
+     */
+    set public_key_y(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmciphertext_l_y(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} public_key_x
+     * @param {string} public_key_y
+     */
+    constructor(public_key_x, public_key_y) {
+        const ptr0 = passStringToWasm0(public_key_x, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(public_key_y, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpublickey_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmPublicKeyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the full public key as fixed-width `0x` + 128 hex digits (x||y).
+     *
+     * Compatible with `deserializePublicKey`.
+     * @returns {string}
+     */
+    publicKeyHex() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmpublickey_publicKeyHex(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmPublicKey.prototype[Symbol.dispose] = WasmPublicKey.prototype.free;
+
 /**
  * Parameters for generating a ragequit proof.
  */
@@ -2428,70 +2644,260 @@ export class WasmRolloverProofResult {
         wasm.__wbg_set_wasmfundparams_nonce(this.__wbg_ptr, ptr0, len0);
     }
 }
-if (Symbol.dispose) WasmRolloverProofResult.prototype[Symbol.dispose] = WasmRolloverProofResult.prototype.free;
+if (Symbol.dispose) WasmRolloverProofResult.prototype[Symbol.dispose] = WasmRolloverProofResult.prototype.free;
+
+/**
+ * Stark ECDSA signature result.
+ */
+export class WasmStarkSignature {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmStarkSignature.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmStarkSignatureFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmStarkSignatureFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmstarksignature_free(ptr, 0);
+    }
+    /**
+     * Public key (hex)
+     * @returns {string}
+     */
+    get publicKey() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmstarksignature_publicKey(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Signature r component (hex)
+     * @returns {string}
+     */
+    get r() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmstarksignature_r(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Signature s component (hex)
+     * @returns {string}
+     */
+    get s() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmstarksignature_s(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Public key (hex)
+     * @param {string} arg0
+     */
+    set publicKey(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmaccountstate_pending_balance(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Signature r component (hex)
+     * @param {string} arg0
+     */
+    set r(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmciphertext_l_x(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Signature s component (hex)
+     * @param {string} arg0
+     */
+    set s(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmciphertext_l_y(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) WasmStarkSignature.prototype[Symbol.dispose] = WasmStarkSignature.prototype.free;
+
+/**
+ * Stark x-only keypair (private key + x-coordinate public key).
+ *
+ * Used by Argent-legacy derivation where `stark_public_key` does not produce Y.
+ *
+ * # Security / threat model
+ *
+ * `private_key` is a plain hex string in the JS heap and cannot be reliably
+ * wiped. Prefer [`WasmStarkXOnlyPublicKey`] when private material is not
+ * required. `Debug` redacts the private key; default `Serialize` omits it.
+ */
+export class WasmStarkXOnlyKeypair {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmStarkXOnlyKeypair.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmStarkXOnlyKeypairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmStarkXOnlyKeypairFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmstarkxonlykeypair_free(ptr, 0);
+    }
+    /**
+     * Private key as hex string (0x-prefixed). Treat as secret.
+     * @returns {string}
+     */
+    get private_key() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmstarkxonlykeypair_private_key(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Public key X coordinate as hex string
+     * @returns {string}
+     */
+    get public_key_x() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_wasmstarkxonlykeypair_public_key_x(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Private key as hex string (0x-prefixed). Treat as secret.
+     * @param {string} arg0
+     */
+    set private_key(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmciphertext_l_x(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Public key X coordinate as hex string
+     * @param {string} arg0
+     */
+    set public_key_x(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmciphertext_l_y(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} private_key
+     * @param {string} public_key_x
+     */
+    constructor(private_key, public_key_x) {
+        const ptr0 = passStringToWasm0(private_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(public_key_x, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmstarkxonlykeypair_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmStarkXOnlyKeypairFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Return the x-only public key as fixed-width `0x` + 64 hex digits.
+     * @returns {string}
+     */
+    publicKeyHex() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmstarkxonlykeypair_publicKeyHex(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmStarkXOnlyKeypair.prototype[Symbol.dispose] = WasmStarkXOnlyKeypair.prototype.free;
 
 /**
- * Stark ECDSA signature result.
+ * Stark public key as an x-only felt (no Y coordinate).
+ *
+ * Matches `stark_public_key` / account address derivation inputs.
  */
-export class WasmStarkSignature {
+export class WasmStarkXOnlyPublicKey {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(WasmStarkSignature.prototype);
+        const obj = Object.create(WasmStarkXOnlyPublicKey.prototype);
         obj.__wbg_ptr = ptr;
-        WasmStarkSignatureFinalization.register(obj, obj.__wbg_ptr, obj);
+        WasmStarkXOnlyPublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmStarkSignatureFinalization.unregister(this);
+        WasmStarkXOnlyPublicKeyFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmstarksignature_free(ptr, 0);
-    }
-    /**
-     * Public key (hex)
-     * @returns {string}
-     */
-    get publicKey() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.__wbg_get_wasmstarksignature_publicKey(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * Signature r component (hex)
-     * @returns {string}
-     */
-    get r() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.__wbg_get_wasmstarksignature_r(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
+        wasm.__wbg_wasmstarkxonlypublickey_free(ptr, 0);
     }
     /**
-     * Signature s component (hex)
+     * Public key X coordinate as hex string
      * @returns {string}
      */
-    get s() {
+    get public_key_x() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.__wbg_get_wasmstarksignature_s(this.__wbg_ptr);
+            const ret = wasm.__wbg_get_wasmstarkxonlypublickey_public_key_x(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -2500,34 +2906,52 @@ export class WasmStarkSignature {
         }
     }
     /**
-     * Public key (hex)
+     * Public key X coordinate as hex string
      * @param {string} arg0
      */
-    set publicKey(arg0) {
+    set public_key_x(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_wasmaccountstate_pending_balance(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_wasmciphertext_l_x(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Signature r component (hex)
-     * @param {string} arg0
+     * @param {string} public_key_x
      */
-    set r(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    constructor(public_key_x) {
+        const ptr0 = passStringToWasm0(public_key_x, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_wasmciphertext_l_x(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.wasmstarkxonlypublickey_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmStarkXOnlyPublicKeyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Signature s component (hex)
-     * @param {string} arg0
+     * Return the x-only public key as fixed-width `0x` + 64 hex digits.
+     * @returns {string}
      */
-    set s(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_wasmciphertext_l_y(this.__wbg_ptr, ptr0, len0);
+    publicKeyHex() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmstarkxonlypublickey_publicKeyHex(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
     }
 }
-if (Symbol.dispose) WasmStarkSignature.prototype[Symbol.dispose] = WasmStarkSignature.prototype.free;
+if (Symbol.dispose) WasmStarkXOnlyPublicKey.prototype[Symbol.dispose] = WasmStarkXOnlyPublicKey.prototype.free;
 
 /**
  * Parameters for generating a transfer proof.
@@ -4986,6 +5410,14 @@ export function deriveArgentAccountAddress(public_key, class_hash) {
  * This is needed to recover keys for accounts created with old Argent-X.
  * Braavos and new Argent use direct `m/44'/9004'/0'/0/{index}` derivation instead.
  *
+ * Returns an x-only Stark keypair ([`WasmStarkXOnlyKeypair`]) because
+ * `stark_public_key` does not produce an affine Y coordinate.
+ *
+ * # Security / threat model
+ *
+ * Returns the private key as a hex string in the JS heap. Prefer
+ * [`derive_argent_legacy_public_key`] when only the public key is needed.
+ *
  * # Arguments
  * * `mnemonic` - 12 or 24 word BIP-39 mnemonic
  * * `address_index` - HD wallet address index (default: 0)
@@ -4993,7 +5425,7 @@ export function deriveArgentAccountAddress(public_key, class_hash) {
  * @param {string} mnemonic
  * @param {number} address_index
  * @param {number} account_index
- * @returns {WasmKeypair}
+ * @returns {WasmStarkXOnlyKeypair}
  */
 export function deriveArgentLegacyKeypair(mnemonic, address_index, account_index) {
     const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -5002,7 +5434,28 @@ export function deriveArgentLegacyKeypair(mnemonic, address_index, account_index
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return WasmKeypair.__wrap(ret[0]);
+    return WasmStarkXOnlyKeypair.__wrap(ret[0]);
+}
+
+/**
+ * Derive the Argent-legacy Stark public key only (x-coordinate).
+ *
+ * Prefer this over [`derive_argent_legacy_keypair`] when private key material
+ * is not needed. Returns [`WasmStarkXOnlyPublicKey`] because
+ * `stark_public_key` is x-only (not a full affine point).
+ * @param {string} mnemonic
+ * @param {number} address_index
+ * @param {number} account_index
+ * @returns {WasmStarkXOnlyPublicKey}
+ */
+export function deriveArgentLegacyPublicKey(mnemonic, address_index, account_index) {
+    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.deriveArgentLegacyPublicKey(ptr0, len0, address_index, account_index);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmStarkXOnlyPublicKey.__wrap(ret[0]);
 }
 
 /**
@@ -5045,9 +5498,9 @@ export function deriveBraavosAccountAddress(public_key, class_hash) {
 }
 
 /**
- * Derive all unique keypairs for a mnemonic without computing addresses.
+ * Derive discovery keypairs for a mnemonic without computing addresses (public-only).
  *
- * Returns one keypair per derivation scheme per index:
+ * Returns one entry per derivation scheme per index:
  * - **Direct**: `m/44'/9004'/0'/0/{index}` — shared by Braavos, new Argent, OpenZeppelin
  * - **ArgentLegacy**: double derivation via ETH key — used by legacy Argent wallets
  *
@@ -5055,11 +5508,15 @@ export function deriveBraavosAccountAddress(public_key, class_hash) {
  * Use these public keys to query external APIs (e.g., Argent's smart account
  * discovery endpoint) for accounts whose addresses can't be derived locally.
  *
+ * # Security
+ *
+ * Private keys are **not** included. Use
+ * [`derive_discovery_keypairs_with_secrets`] when key material is required.
+ *
  * # Returns
  * JSON string: array of objects with fields:
  * - `derivationType`: "Direct" | "ArgentLegacy"
  * - `publicKey`: hex string
- * - `privateKey`: hex string (handle with care!)
  * - `derivationIndex`: number
  * - `derivationPath`: string
  *
@@ -5098,8 +5555,46 @@ export function deriveDiscoveryKeypairs(mnemonic, max_index) {
     }
 }
 
+/**
+ * Like [`derive_discovery_keypairs`], but includes `privateKey` on each entry.
+ *
+ * # Security
+ *
+ * **Opt-in secret API.** Treat the returned JSON as secret material.
+ * @param {string} mnemonic
+ * @param {number | null} [max_index]
+ * @returns {string}
+ */
+export function deriveDiscoveryKeypairsWithSecrets(mnemonic, max_index) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.deriveDiscoveryKeypairsWithSecrets(ptr0, len0, isLikeNone(max_index) ? 0x100000001 : (max_index) >>> 0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Derive a keypair from mnemonic (for external use).
+ *
+ * # Security / threat model
+ *
+ * Returns the private key as a hex string in the JS heap. Prefer
+ * [`derive_public_key`] when only the public key is needed. Never log the
+ * returned [`WasmKeypair`]; its `Debug` form redacts the private key, but
+ * JS property access still exposes it.
  * @param {string} mnemonic
  * @param {number} address_index
  * @param {number} account_index
@@ -5126,6 +5621,11 @@ export function deriveKeypair(mnemonic, address_index, account_index, passphrase
  *
  * Derivation path: m/44'/1237'/{account_index}'/0/{address_index}
  *
+ * # Security / threat model
+ *
+ * Returns the private key as a hex string in the JS heap. Prefer
+ * [`derive_nostr_public_key`] when only the public key is needed.
+ *
  * # Arguments
  * * `mnemonic` - 12 or 24 word BIP-39 mnemonic
  * * `address_index` - HD wallet address index (default: 0)
@@ -5152,6 +5652,28 @@ export function deriveNostrKeypair(mnemonic, address_index, account_index, passp
     return WasmNostrKeypair.__wrap(ret[0]);
 }
 
+/**
+ * Derive the Nostr x-only public key only from a mnemonic (coin type 1237).
+ *
+ * Prefer this over [`derive_nostr_keypair`] when private key material is not needed.
+ * @param {string} mnemonic
+ * @param {number} address_index
+ * @param {number} account_index
+ * @param {string | null} [passphrase]
+ * @returns {WasmNostrPublicKey}
+ */
+export function deriveNostrPublicKey(mnemonic, address_index, account_index, passphrase) {
+    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(passphrase) ? 0 : passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.deriveNostrPublicKey(ptr0, len0, address_index, account_index, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmNostrPublicKey.__wrap(ret[0]);
+}
+
 /**
  * Derive an OpenZeppelin account contract address from a public key.
  *
@@ -5161,7 +5683,7 @@ export function deriveNostrKeypair(mnemonic, address_index, account_index, passp
  * # Arguments
  * * `public_key_x` - The x-coordinate of the Stark public key (hex string)
  * * `class_hash` - The OpenZeppelin account class hash (hex string)
- * * `salt` - Optional salt for address derivation (hex string, defaults to "0x0")
+ * * `salt` - Optional salt for address derivation (hex string; defaults to the public key)
  *
  * # Returns
  * The derived account contract address as hex string
@@ -5195,12 +5717,39 @@ export function deriveOzAccountAddress(public_key_x, class_hash, salt) {
     }
 }
 
+/**
+ * Derive the public key only from a mnemonic (Tongo coin type).
+ *
+ * Prefer this over [`derive_keypair`] when private key material is not needed.
+ * @param {string} mnemonic
+ * @param {number} address_index
+ * @param {number} account_index
+ * @param {string | null} [passphrase]
+ * @returns {WasmPublicKey}
+ */
+export function derivePublicKey(mnemonic, address_index, account_index, passphrase) {
+    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(passphrase) ? 0 : passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.derivePublicKey(ptr0, len0, address_index, account_index, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmPublicKey.__wrap(ret[0]);
+}
+
 /**
  * Derive a Starknet account keypair from mnemonic (coin type 9004).
  *
  * This is used for signing Starknet transactions and deriving the
  * OpenZeppelin account contract address.
  *
+ * # Security / threat model
+ *
+ * Returns the private key as a hex string in the JS heap. Prefer
+ * [`derive_starknet_public_key`] when only the public key is needed.
+ *
  * # Arguments
  * * `mnemonic` - 12 or 24 word BIP-39 mnemonic
  * * `address_index` - HD wallet address index (default: 0)
@@ -5227,6 +5776,29 @@ export function deriveStarknetKeypair(mnemonic, address_index, account_index, pa
     return WasmKeypair.__wrap(ret[0]);
 }
 
+/**
+ * Derive the Starknet public key only from a mnemonic (coin type 9004).
+ *
+ * Prefer this over [`derive_starknet_keypair`] when private key material is
+ * not needed (e.g. address derivation).
+ * @param {string} mnemonic
+ * @param {number} address_index
+ * @param {number} account_index
+ * @param {string | null} [passphrase]
+ * @returns {WasmPublicKey}
+ */
+export function deriveStarknetPublicKey(mnemonic, address_index, account_index, passphrase) {
+    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(passphrase) ? 0 : passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.deriveStarknetPublicKey(ptr0, len0, address_index, account_index, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmPublicKey.__wrap(ret[0]);
+}
+
 /**
  * Derive the STRK20 viewing key from a Stark private key.
  *
@@ -5284,14 +5856,19 @@ export function deserializePublicKey(hex) {
 }
 
 /**
- * Perform full account discovery in a single call.
+ * Perform full account discovery in a single call (public-only).
  *
  * Returns a JSON object with two fields:
- * - `keypairs`: array of DerivedKeypair objects (for API-based smart account lookup)
- * - `candidates`: array of CandidateAccount objects (for local address derivation)
+ * - `keypairs`: array of public-only DerivedKeypair objects (for API-based smart account lookup)
+ * - `candidates`: array of public-only CandidateAccount objects (for local address derivation)
  *
  * This combines `deriveDiscoveryKeypairs` and `generateAccountCandidates` into
  * a single WASM call, eliminating one JS→WASM round-trip.
+ *
+ * # Security
+ *
+ * Private keys are **not** included. Use
+ * [`discover_accounts_from_mnemonic_with_secrets`] when key material is required.
  * @param {string} mnemonic
  * @param {number | null} [max_index]
  * @returns {string}
@@ -5317,6 +5894,37 @@ export function discoverAccountsFromMnemonic(mnemonic, max_index) {
     }
 }
 
+/**
+ * Like [`discover_accounts_from_mnemonic`], but includes private keys.
+ *
+ * # Security
+ *
+ * **Opt-in secret API.** Treat the returned JSON as secret material.
+ * @param {string} mnemonic
+ * @param {number | null} [max_index]
+ * @returns {string}
+ */
+export function discoverAccountsFromMnemonicWithSecrets(mnemonic, max_index) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.discoverAccountsFromMnemonicWithSecrets(ptr0, len0, isLikeNone(max_index) ? 0x100000001 : (max_index) >>> 0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Encode a value as a Felt hex string.
  *
@@ -5466,7 +6074,7 @@ export function encryptWithKey(plaintext, key_hex) {
  *
  * Returns a JSON object where keys are derivation indices and values are
  * objects mapping wallet type to address. Useful for quick discovery without
- * needing the full candidate details.
+ * needing the full candidate details. Never includes private keys.
  *
  * # Returns
  * JSON string: `{ "0": { "Braavos": "0x...", "Argent": "0x...", ... }, "1": { ... } }`
@@ -5496,7 +6104,7 @@ export function generateAccountAddresses(mnemonic, max_index) {
 }
 
 /**
- * Generate all candidate account addresses for a mnemonic.
+ * Generate all candidate account addresses for a mnemonic (public-only).
  *
  * Returns a JSON array of candidate accounts across all known wallet types
  * (Braavos, Argent, Argent Legacy, Argent Cairo 0, OpenZeppelin).
@@ -5506,6 +6114,11 @@ export function generateAccountAddresses(mnemonic, max_index) {
  * ones are actually deployed, check each address via an RPC provider
  * (e.g., `provider.getClassHashAt(address)` in starknet.js).
  *
+ * # Security
+ *
+ * Private keys are **not** included (default `CandidateAccount` Serialize).
+ * Use [`generate_account_candidates_with_secrets`] when key material is required.
+ *
  * # Arguments
  * * `mnemonic` - BIP-39 mnemonic phrase (12 or 24 words)
  * * `max_index` - Maximum derivation index to scan (default: 5).
@@ -5517,7 +6130,6 @@ export function generateAccountAddresses(mnemonic, max_index) {
  * - `classHash`: hex string
  * - `address`: hex string
  * - `publicKey`: hex string
- * - `privateKey`: hex string (handle with care!)
  * - `derivationIndex`: number
  * - `derivationPath`: string (e.g., "m/44'/9004'/0'/0/0")
  * - `classVersion`: string (e.g., "v0.4.0", "braavos-base")
@@ -5557,6 +6169,39 @@ export function generateAccountCandidates(mnemonic, max_index) {
     }
 }
 
+/**
+ * Like [`generate_account_candidates`], but includes `privateKey` on each candidate.
+ *
+ * # Security
+ *
+ * **Opt-in secret API.** The returned JSON contains private keys. Do not log,
+ * cache in localStorage, or pass through untrusted JavaScript. Prefer the
+ * default public-only API for discovery scans.
+ * @param {string} mnemonic
+ * @param {number | null} [max_index]
+ * @returns {string}
+ */
+export function generateAccountCandidatesWithSecrets(mnemonic, max_index) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.generateAccountCandidatesWithSecrets(ptr0, len0, isLikeNone(max_index) ? 0x100000001 : (max_index) >>> 0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Generate a fund (deposit) proof.
  * @param {WasmAccount} account
@@ -5575,6 +6220,13 @@ export function generateFundProof(account, params) {
 
 /**
  * Generate a new random mnemonic phrase.
+ *
+ * # Security / threat model
+ *
+ * The mnemonic is returned as a plain JavaScript string and cannot be
+ * reliably wiped from the JS heap. Treat it as high-value secret material:
+ * never log it, never persist it unencrypted, and prefer keeping it only in
+ * secure storage after generation.
  * @param {number | null} [word_count]
  * @returns {string}
  */
@@ -6566,12 +7218,18 @@ const WasmKeypairFinalization = (typeof FinalizationRegistry === 'undefined')
 const WasmNostrKeypairFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmnostrkeypair_free(ptr >>> 0, 1));
+const WasmNostrPublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmnostrpublickey_free(ptr >>> 0, 1));
 const WasmNostrSignatureFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmnostrsignature_free(ptr >>> 0, 1));
 const WasmPointFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmpoint_free(ptr >>> 0, 1));
+const WasmPublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpublickey_free(ptr >>> 0, 1));
 const WasmRagequitParamsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmragequitparams_free(ptr >>> 0, 1));
@@ -6587,6 +7245,12 @@ const WasmRolloverProofResultFinalization = (typeof FinalizationRegistry === 'un
 const WasmStarkSignatureFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmstarksignature_free(ptr >>> 0, 1));
+const WasmStarkXOnlyKeypairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstarkxonlykeypair_free(ptr >>> 0, 1));
+const WasmStarkXOnlyPublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstarkxonlypublickey_free(ptr >>> 0, 1));
 const WasmTransferParamsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmtransferparams_free(ptr >>> 0, 1));