@breeztech/breez-sdk-spark 0.18.0-dev4 → 0.18.0

package/nodejs/breez_sdk_spark_wasm.d.ts

@@ -886,6 +886,13 @@ export interface ExternalSigningCommitments {
     binding: number[];
 }
 
+export interface ExternalSigningSigner {
+    derivePublicKey(path: string): Promise<PublicKeyBytes>;
+    signEcdsa(message: MessageBytes, path: string): Promise<EcdsaSignatureBytes>;
+    signEcdsaRecoverable(message: MessageBytes, path: string): Promise<RecoverableEcdsaSignatureBytes>;
+    signHashSchnorr(hash: Uint8Array, path: string): Promise<SchnorrSignatureBytes>;
+}
+
 export interface ExternalSparkSigner {
     getIdentityPublicKey(): Promise<PublicKeyBytes>;
     getPublicKeyForLeaf(leafId: ExternalTreeNodeId): Promise<PublicKeyBytes>;
@@ -1885,6 +1892,24 @@ export class ExternalSigners {
     readonly sparkSigner: ExternalSparkSignerHandle;
 }
 
+/**
+ * A Rust-backed [`ExternalSigningSigner`] surfaced to JS as a signer object
+ * that can be passed to `connectWithSigningOnlySigner` or
+ * `SdkBuilder.newWithSigningOnlySigner`. Produced by
+ * `createTurnkeySigningOnlySigner`.
+ *
+ * [`ExternalSigningSigner`]: breez_sdk_spark::signer::ExternalSigningSigner
+ */
+export class ExternalSigningSignerHandle {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    derivePublicKey(path: string): Promise<PublicKeyBytes>;
+    signEcdsa(message: MessageBytes, path: string): Promise<EcdsaSignatureBytes>;
+    signEcdsaRecoverable(message: MessageBytes, path: string): Promise<RecoverableEcdsaSignatureBytes>;
+    signHashSchnorr(hash: Uint8Array, path: string): Promise<SchnorrSignatureBytes>;
+}
+
 /**
  * A Rust-backed [`ExternalSparkSigner`] surfaced to JS as a signer object that
  * can be passed to `connectWithSigner` or `SdkBuilder.newWithSigner`. Produced
@@ -2004,6 +2029,13 @@ export class SdkBuilder {
     build(): Promise<BreezSdk>;
     static new(config: Config, seed: Seed): SdkBuilder;
     static newWithSigner(config: Config, breez_signer: ExternalBreezSigner, spark_signer: ExternalSparkSigner): SdkBuilder;
+    /**
+     * Creates a new `SdkBuilder` with a signing-only external signer, for a
+     * signer that can't perform the SDK's local ECIES/HMAC operations. The SDK
+     * keeps session tokens in plaintext and disables the features that rely on
+     * ECIES/HMAC.
+     */
+    static newWithSigningOnlySigner(config: Config, breez_signer: ExternalSigningSigner, spark_signer: ExternalSparkSigner): SdkBuilder;
     withAccountNumber(account_number: number): SdkBuilder;
     withChainService(chain_service: BitcoinChainService): SdkBuilder;
     withDefaultStorage(storage_dir: string): Promise<SdkBuilder>;
@@ -2037,6 +2069,25 @@ export class SdkBuilder {
     withStorageBackend(config: WasmStorageConfig): SdkBuilder;
 }
 
+/**
+ * The signing-only external signers for the SDK's signer-based connect.
+ * Returned by `createTurnkeySigningOnlySigner`; pass both halves to
+ * `connectWithSigningOnlySigner` or `SdkBuilder.newWithSigningOnlySigner`.
+ */
+export class SigningOnlyExternalSigners {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Signing-only external signer for non-Spark SDK signing.
+     */
+    readonly breezSigner: ExternalSigningSignerHandle;
+    /**
+     * External high-level Spark signer for the Spark wallet flows.
+     */
+    readonly sparkSigner: ExternalSparkSignerHandle;
+}
+
 export class TokenIssuer {
     private constructor();
     free(): void;
@@ -2079,6 +2130,13 @@ export function connect(request: ConnectRequest): Promise<BreezSdk>;
 
 export function connectWithSigner(config: Config, breez_signer: ExternalBreezSigner, spark_signer: ExternalSparkSigner, storage_dir: string): Promise<BreezSdk>;
 
+/**
+ * Connects using a signing-only external signer, for a signer that can't
+ * perform the SDK's local ECIES/HMAC operations. The SDK keeps session tokens
+ * in plaintext and disables the features that rely on ECIES/HMAC.
+ */
+export function connectWithSigningOnlySigner(config: Config, breez_signer: ExternalSigningSigner, spark_signer: ExternalSparkSigner, storage_dir: string): Promise<BreezSdk>;
+
 /**
  * Builds the Turnkey-backed signers from `config`, then pass
  * `signers.breezSigner` and `signers.sparkSigner` to `connectWithSigner`,
@@ -2086,6 +2144,14 @@ export function connectWithSigner(config: Config, breez_signer: ExternalBreezSig
  */
 export function createTurnkeySigner(config: TurnkeyConfig): Promise<ExternalSigners>;
 
+/**
+ * Builds the signing-only Turnkey-backed signers from `config` (for a wallet
+ * under a deny-export policy), then pass `signers.breezSigner` and
+ * `signers.sparkSigner` to `connectWithSigningOnlySigner`. The Breez half
+ * performs signing only and never exports a key.
+ */
+export function createTurnkeySigningOnlySigner(config: TurnkeyConfig): Promise<SigningOnlyExternalSigners>;
+
 export function defaultConfig(network: Network): Config;
 
 /**

package/nodejs/breez_sdk_spark_wasm.js

@@ -616,6 +616,80 @@ class ExternalSigners {
 if (Symbol.dispose) ExternalSigners.prototype[Symbol.dispose] = ExternalSigners.prototype.free;
 exports.ExternalSigners = ExternalSigners;
 
+/**
+ * A Rust-backed [`ExternalSigningSigner`] surfaced to JS as a signer object
+ * that can be passed to `connectWithSigningOnlySigner` or
+ * `SdkBuilder.newWithSigningOnlySigner`. Produced by
+ * `createTurnkeySigningOnlySigner`.
+ *
+ * [`ExternalSigningSigner`]: breez_sdk_spark::signer::ExternalSigningSigner
+ */
+class ExternalSigningSignerHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(ExternalSigningSignerHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        ExternalSigningSignerHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExternalSigningSignerHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_externalsigningsignerhandle_free(ptr, 0);
+    }
+    /**
+     * @param {string} path
+     * @returns {Promise<PublicKeyBytes>}
+     */
+    derivePublicKey(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.externalsigningsignerhandle_derivePublicKey(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {MessageBytes} message
+     * @param {string} path
+     * @returns {Promise<EcdsaSignatureBytes>}
+     */
+    signEcdsa(message, path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.externalsigningsignerhandle_signEcdsa(this.__wbg_ptr, message, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {MessageBytes} message
+     * @param {string} path
+     * @returns {Promise<RecoverableEcdsaSignatureBytes>}
+     */
+    signEcdsaRecoverable(message, path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.externalsigningsignerhandle_signEcdsaRecoverable(this.__wbg_ptr, message, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} hash
+     * @param {string} path
+     * @returns {Promise<SchnorrSignatureBytes>}
+     */
+    signHashSchnorr(hash, path) {
+        const ptr0 = passArray8ToWasm0(hash, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.externalsigningsignerhandle_signHashSchnorr(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+}
+if (Symbol.dispose) ExternalSigningSignerHandle.prototype[Symbol.dispose] = ExternalSigningSignerHandle.prototype.free;
+exports.ExternalSigningSignerHandle = ExternalSigningSignerHandle;
+
 /**
  * A Rust-backed [`ExternalSparkSigner`] surfaced to JS as a signer object that
  * can be passed to `connectWithSigner` or `SdkBuilder.newWithSigner`. Produced
@@ -1047,6 +1121,20 @@ class SdkBuilder {
         const ret = wasm.sdkbuilder_newWithSigner(config, breez_signer, spark_signer);
         return SdkBuilder.__wrap(ret);
     }
+    /**
+     * Creates a new `SdkBuilder` with a signing-only external signer, for a
+     * signer that can't perform the SDK's local ECIES/HMAC operations. The SDK
+     * keeps session tokens in plaintext and disables the features that rely on
+     * ECIES/HMAC.
+     * @param {Config} config
+     * @param {ExternalSigningSigner} breez_signer
+     * @param {ExternalSparkSigner} spark_signer
+     * @returns {SdkBuilder}
+     */
+    static newWithSigningOnlySigner(config, breez_signer, spark_signer) {
+        const ret = wasm.sdkbuilder_newWithSigningOnlySigner(config, breez_signer, spark_signer);
+        return SdkBuilder.__wrap(ret);
+    }
     /**
      * @param {number} account_number
      * @returns {SdkBuilder}
@@ -1185,6 +1273,48 @@ class SdkBuilder {
 if (Symbol.dispose) SdkBuilder.prototype[Symbol.dispose] = SdkBuilder.prototype.free;
 exports.SdkBuilder = SdkBuilder;
 
+/**
+ * The signing-only external signers for the SDK's signer-based connect.
+ * Returned by `createTurnkeySigningOnlySigner`; pass both halves to
+ * `connectWithSigningOnlySigner` or `SdkBuilder.newWithSigningOnlySigner`.
+ */
+class SigningOnlyExternalSigners {
+    static __wrap(ptr) {
+        const obj = Object.create(SigningOnlyExternalSigners.prototype);
+        obj.__wbg_ptr = ptr;
+        SigningOnlyExternalSignersFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SigningOnlyExternalSignersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signingonlyexternalsigners_free(ptr, 0);
+    }
+    /**
+     * Signing-only external signer for non-Spark SDK signing.
+     * @returns {ExternalSigningSignerHandle}
+     */
+    get breezSigner() {
+        const ret = wasm.signingonlyexternalsigners_breezSigner(this.__wbg_ptr);
+        return ExternalSigningSignerHandle.__wrap(ret);
+    }
+    /**
+     * External high-level Spark signer for the Spark wallet flows.
+     * @returns {ExternalSparkSignerHandle}
+     */
+    get sparkSigner() {
+        const ret = wasm.signingonlyexternalsigners_sparkSigner(this.__wbg_ptr);
+        return ExternalSparkSignerHandle.__wrap(ret);
+    }
+}
+if (Symbol.dispose) SigningOnlyExternalSigners.prototype[Symbol.dispose] = SigningOnlyExternalSigners.prototype.free;
+exports.SigningOnlyExternalSigners = SigningOnlyExternalSigners;
+
 class TokenIssuer {
     static __wrap(ptr) {
         const obj = Object.create(TokenIssuer.prototype);
@@ -1340,6 +1470,24 @@ function connectWithSigner(config, breez_signer, spark_signer, storage_dir) {
 }
 exports.connectWithSigner = connectWithSigner;
 
+/**
+ * Connects using a signing-only external signer, for a signer that can't
+ * perform the SDK's local ECIES/HMAC operations. The SDK keeps session tokens
+ * in plaintext and disables the features that rely on ECIES/HMAC.
+ * @param {Config} config
+ * @param {ExternalSigningSigner} breez_signer
+ * @param {ExternalSparkSigner} spark_signer
+ * @param {string} storage_dir
+ * @returns {Promise<BreezSdk>}
+ */
+function connectWithSigningOnlySigner(config, breez_signer, spark_signer, storage_dir) {
+    const ptr0 = passStringToWasm0(storage_dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.connectWithSigningOnlySigner(config, breez_signer, spark_signer, ptr0, len0);
+    return ret;
+}
+exports.connectWithSigningOnlySigner = connectWithSigningOnlySigner;
+
 /**
  * Builds the Turnkey-backed signers from `config`, then pass
  * `signers.breezSigner` and `signers.sparkSigner` to `connectWithSigner`,
@@ -1353,6 +1501,20 @@ function createTurnkeySigner(config) {
 }
 exports.createTurnkeySigner = createTurnkeySigner;
 
+/**
+ * Builds the signing-only Turnkey-backed signers from `config` (for a wallet
+ * under a deny-export policy), then pass `signers.breezSigner` and
+ * `signers.sparkSigner` to `connectWithSigningOnlySigner`. The Breez half
+ * performs signing only and never exports a key.
+ * @param {TurnkeyConfig} config
+ * @returns {Promise<SigningOnlyExternalSigners>}
+ */
+function createTurnkeySigningOnlySigner(config) {
+    const ret = wasm.createTurnkeySigningOnlySigner(config);
+    return ret;
+}
+exports.createTurnkeySigningOnlySigner = createTurnkeySigningOnlySigner;
+
 /**
  * @param {Network} network
  * @returns {Config}
@@ -1947,6 +2109,18 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments); },
+        __wbg_derivePublicKey_db43f40bd54e092a: function() { return handleError(function (arg0, arg1, arg2) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg1;
+                deferred0_1 = arg2;
+                const ret = arg0.derivePublicKey(getStringFromWasm0(arg1, arg2));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
         __wbg_deriveSeeds_5c331613e2894c56: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.deriveSeeds(arg1, arg2);
             return ret;
@@ -2827,6 +3001,18 @@ function __wbg_get_imports() {
             const ret = arg0.signAuthenticationChallenge(v0);
             return ret;
         }, arguments); },
+        __wbg_signEcdsaRecoverable_7a9da0490e388132: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg2;
+                deferred0_1 = arg3;
+                const ret = arg0.signEcdsaRecoverable(arg1, getStringFromWasm0(arg2, arg3));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
         __wbg_signEcdsaRecoverable_978c5526e66a433b: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
@@ -2851,10 +3037,36 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments); },
+        __wbg_signEcdsa_89f0abf313463778: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg2;
+                deferred0_1 = arg3;
+                const ret = arg0.signEcdsa(arg1, getStringFromWasm0(arg2, arg3));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
         __wbg_signFrost_08951e01d00d4b1c: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.signFrost(arg1);
             return ret;
         }, arguments); },
+        __wbg_signHashSchnorr_881022637f4bf583: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+                wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+                deferred1_0 = arg3;
+                deferred1_1 = arg4;
+                const ret = arg0.signHashSchnorr(v0, getStringFromWasm0(arg3, arg4));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }, arguments); },
         __wbg_signHashSchnorr_fc8afda9a7ee021a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             let deferred1_0;
             let deferred1_1;
@@ -2887,6 +3099,10 @@ function __wbg_get_imports() {
             const ret = arg0.signal;
             return ret;
         },
+        __wbg_signingonlyexternalsigners_new: function(arg0) {
+            const ret = SigningOnlyExternalSigners.__wrap(arg0);
+            return ret;
+        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -3063,61 +3279,61 @@ function __wbg_get_imports() {
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h38afe039e8450492);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 215, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 219, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 215, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 219, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_2);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 215, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 219, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_3);
             return ret;
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 215, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 219, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_4);
             return ret;
         },
         __wbindgen_cast_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 215, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 219, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_5);
             return ret;
         },
         __wbindgen_cast_0000000000000007: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("SessionStore")], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_6);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_6);
             return ret;
         },
         __wbindgen_cast_0000000000000008: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Storage")], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_7);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_7);
             return ret;
         },
         __wbindgen_cast_0000000000000009: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TokenStore")], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_8);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_8);
             return ret;
         },
         __wbindgen_cast_000000000000000a: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TreeStore")], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_9);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_9);
             return ret;
         },
         __wbindgen_cast_000000000000000b: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 399, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 393, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h1d6669a7b693932a);
             return ret;
         },
         __wbindgen_cast_000000000000000c: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 429, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 422, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
             const ret = makeClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h0fa3f876e31d2a3e);
             return ret;
         },
@@ -3237,36 +3453,36 @@ function wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_5(arg0, a
     wasm.wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_5(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h38afe039e8450492(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h38afe039e8450492(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_6(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_6(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_6(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_6(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_7(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_7(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_7(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_7(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_8(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_8(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_8(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_8(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_9(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_9(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_9(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_9(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
@@ -3308,6 +3524,9 @@ const ExternalBreezSignerHandleFinalization = (typeof FinalizationRegistry === '
 const ExternalSignersFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_externalsigners_free(ptr, 1));
+const ExternalSigningSignerHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_externalsigningsignerhandle_free(ptr, 1));
 const ExternalSparkSignerHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_externalsparksignerhandle_free(ptr, 1));
@@ -3329,6 +3548,9 @@ const PasskeyLabelsFinalization = (typeof FinalizationRegistry === 'undefined')
 const SdkBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sdkbuilder_free(ptr, 1));
+const SigningOnlyExternalSignersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signingonlyexternalsigners_free(ptr, 1));
 const TokenIssuerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tokenissuer_free(ptr, 1));

package/nodejs/breez_sdk_spark_wasm_bg.wasm.d.ts

@@ -63,7 +63,9 @@ export const breezsdk_updateContact: (a: number, b: any) => any;
 export const breezsdk_updateUserSettings: (a: number, b: any) => any;
 export const connect: (a: any) => any;
 export const connectWithSigner: (a: any, b: any, c: any, d: number, e: number) => any;
+export const connectWithSigningOnlySigner: (a: any, b: any, c: any, d: number, e: number) => any;
 export const createTurnkeySigner: (a: any) => any;
+export const createTurnkeySigningOnlySigner: (a: any) => any;
 export const defaultConfig: (a: any) => any;
 export const defaultExternalSigners: (a: number, b: number, c: number, d: number, e: any, f: number) => [number, number, number];
 export const defaultMysqlStorageConfig: (a: number, b: number) => any;
@@ -79,6 +81,10 @@ export const externalbreezsignerhandle_signEcdsaRecoverable: (a: number, b: any,
 export const externalbreezsignerhandle_signHashSchnorr: (a: number, b: number, c: number, d: number, e: number) => any;
 export const externalsigners_breezSigner: (a: number) => number;
 export const externalsigners_sparkSigner: (a: number) => number;
+export const externalsigningsignerhandle_derivePublicKey: (a: number, b: number, c: number) => any;
+export const externalsigningsignerhandle_signEcdsa: (a: number, b: any, c: number, d: number) => any;
+export const externalsigningsignerhandle_signEcdsaRecoverable: (a: number, b: any, c: number, d: number) => any;
+export const externalsigningsignerhandle_signHashSchnorr: (a: number, b: number, c: number, d: number, e: number) => any;
 export const externalsparksignerhandle_getIdentityPublicKey: (a: number) => any;
 export const externalsparksignerhandle_getPublicKeyForLeaf: (a: number, b: any) => any;
 export const externalsparksignerhandle_getStaticDepositPublicKey: (a: number, b: number) => any;
@@ -110,6 +116,7 @@ export const postgresStorage: (a: any) => number;
 export const sdkbuilder_build: (a: number) => any;
 export const sdkbuilder_new: (a: any, b: any) => number;
 export const sdkbuilder_newWithSigner: (a: any, b: any, c: any) => number;
+export const sdkbuilder_newWithSigningOnlySigner: (a: any, b: any, c: any) => number;
 export const sdkbuilder_withAccountNumber: (a: number, b: number) => number;
 export const sdkbuilder_withChainService: (a: number, b: any) => number;
 export const sdkbuilder_withDefaultStorage: (a: number, b: number, c: number) => any;
@@ -150,11 +157,15 @@ export const intounderlyingsource_cancel: (a: number) => void;
 export const intounderlyingsource_pull: (a: number, b: any) => any;
 export const __wbg_externalbreezsignerhandle_free: (a: number, b: number) => void;
 export const __wbg_externalsparksignerhandle_free: (a: number, b: number) => void;
-export const wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_6: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_7: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_8: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h039d35996dc01d12_9: (a: number, b: number, c: any) => [number, number];
+export const __wbg_externalsigningsignerhandle_free: (a: number, b: number) => void;
+export const __wbg_signingonlyexternalsigners_free: (a: number, b: number) => void;
+export const signingonlyexternalsigners_breezSigner: (a: number) => number;
+export const signingonlyexternalsigners_sparkSigner: (a: number) => number;
+export const wasm_bindgen__convert__closures_____invoke__h38afe039e8450492: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_6: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_7: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_8: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h38afe039e8450492_9: (a: number, b: number, c: any) => [number, number];
 export const wasm_bindgen__convert__closures_____invoke__h41057d61edf43a32: (a: number, b: number, c: any, d: any) => void;
 export const wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2: (a: number, b: number, c: any) => void;
 export const wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_2: (a: number, b: number, c: any) => void;

package/nodejs/index.mjs

@@ -6,7 +6,9 @@ import pkg from './index.js';
 export const {
   connect,
   connectWithSigner,
+  connectWithSigningOnlySigner,
   createTurnkeySigner,
+  createTurnkeySigningOnlySigner,
   defaultConfig,
   defaultExternalSigners,
   defaultMysqlStorageConfig,
@@ -25,6 +27,7 @@ export const {
   BreezSdk,
   ExternalBreezSignerHandle,
   ExternalSigners,
+  ExternalSigningSignerHandle,
   ExternalSparkSignerHandle,
   IntoUnderlyingByteSource,
   IntoUnderlyingSink,
@@ -32,6 +35,7 @@ export const {
   PasskeyClient,
   PasskeyLabels,
   SdkBuilder,
+  SigningOnlyExternalSigners,
   TokenIssuer,
   WasmSdkContext,
   WasmStorageConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@breeztech/breez-sdk-spark",
-    "version": "0.18.0-dev4",
+    "version": "0.18.0",
     "description": "Breez Spark SDK",
     "repository": "https://github.com/breez/spark-sdk",
     "author": "Breez <contact@breez.technology> (https://github.com/breez)",

package/ssr/index.js

@@ -33,11 +33,21 @@ export function connectWithSigner(...args) {
   return _module.connectWithSigner(...args);
 }
 
+export function connectWithSigningOnlySigner(...args) {
+  if (!_module) _notInitialized('connectWithSigningOnlySigner');
+  return _module.connectWithSigningOnlySigner(...args);
+}
+
 export function createTurnkeySigner(...args) {
   if (!_module) _notInitialized('createTurnkeySigner');
   return _module.createTurnkeySigner(...args);
 }
 
+export function createTurnkeySigningOnlySigner(...args) {
+  if (!_module) _notInitialized('createTurnkeySigningOnlySigner');
+  return _module.createTurnkeySigningOnlySigner(...args);
+}
+
 export function defaultConfig(...args) {
   if (!_module) _notInitialized('defaultConfig');
   return _module.defaultConfig(...args);
@@ -141,6 +151,13 @@ export class ExternalSigners {
   }
 }
 
+export class ExternalSigningSignerHandle {
+  constructor(...args) {
+    if (!_module) _notInitialized('new ExternalSigningSignerHandle');
+    return new _module.ExternalSigningSignerHandle(...args);
+  }
+}
+
 export class ExternalSparkSignerHandle {
   constructor(...args) {
     if (!_module) _notInitialized('new ExternalSparkSignerHandle');
@@ -190,6 +207,13 @@ export class SdkBuilder {
   }
 }
 
+export class SigningOnlyExternalSigners {
+  constructor(...args) {
+    if (!_module) _notInitialized('new SigningOnlyExternalSigners');
+    return new _module.SigningOnlyExternalSigners(...args);
+  }
+}
+
 export class TokenIssuer {
   constructor(...args) {
     if (!_module) _notInitialized('new TokenIssuer');