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

package/web/breez_sdk_spark_wasm.js

@@ -116,6 +116,22 @@ export class BreezSdk {
         const ret = wasm.breezsdk_authorizeLightningAddressTransfer(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {BuildUnsignedLnurlPayPackageRequest} request
+     * @returns {Promise<UnsignedTransferPackage>}
+     */
+    buildUnsignedLnurlPayPackage(request) {
+        const ret = wasm.breezsdk_buildUnsignedLnurlPayPackage(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {BuildUnsignedTransferPackageRequest} request
+     * @returns {Promise<UnsignedTransferPackage>}
+     */
+    buildUnsignedTransferPackage(request) {
+        const ret = wasm.breezsdk_buildUnsignedTransferPackage(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @param {BuyBitcoinRequest} request
      * @returns {Promise<BuyBitcoinResponse>}
@@ -352,6 +368,22 @@ export class BreezSdk {
         const ret = wasm.breezsdk_prepareSendPayment(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {PublishSignedLnurlPayPackageRequest} request
+     * @returns {Promise<PublishSignedLnurlPayResponse>}
+     */
+    publishSignedLnurlPayPackage(request) {
+        const ret = wasm.breezsdk_publishSignedLnurlPayPackage(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {PublishSignedTransferPackageRequest} request
+     * @returns {Promise<PublishSignedTransferPackageResponse>}
+     */
+    publishSignedTransferPackage(request) {
+        const ret = wasm.breezsdk_publishSignedTransferPackage(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @param {ReceivePaymentRequest} request
      * @returns {Promise<ReceivePaymentResponse>}
@@ -459,6 +491,54 @@ export class BreezSdk {
 }
 if (Symbol.dispose) BreezSdk.prototype[Symbol.dispose] = BreezSdk.prototype.free;
 
+/**
+ * A JS handle to a backend's own session store (from `defaultSessionStore`),
+ * exposing the same `getSession` / `setSession` interface. Wrap it in a JS
+ * `SessionStore` decorator and pass that to `SdkBuilder.withSessionStore` to
+ * transform tokens while keeping the backend's persistence: for example
+ * at-rest encryption, which the SDK does not apply itself.
+ */
+export class DefaultSessionStore {
+    static __wrap(ptr) {
+        const obj = Object.create(DefaultSessionStore.prototype);
+        obj.__wbg_ptr = ptr;
+        DefaultSessionStoreFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DefaultSessionStoreFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_defaultsessionstore_free(ptr, 0);
+    }
+    /**
+     * @param {string} service_identity_key
+     * @returns {Promise<Session>}
+     */
+    getSession(service_identity_key) {
+        const ptr0 = passStringToWasm0(service_identity_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultsessionstore_getSession(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} service_identity_key
+     * @param {Session} session
+     * @returns {Promise<void>}
+     */
+    setSession(service_identity_key, session) {
+        const ptr0 = passStringToWasm0(service_identity_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultsessionstore_setSession(this.__wbg_ptr, ptr0, len0, session);
+        return ret;
+    }
+}
+if (Symbol.dispose) DefaultSessionStore.prototype[Symbol.dispose] = DefaultSessionStore.prototype.free;
+
 /**
  * A Rust-backed [`ExternalBreezSigner`] surfaced to JS as a signer object that
  * can be passed to `connectWithSigner` or `SdkBuilder.newWithSigner`. Produced
@@ -612,6 +692,79 @@ export class ExternalSigners {
 }
 if (Symbol.dispose) ExternalSigners.prototype[Symbol.dispose] = ExternalSigners.prototype.free;
 
+/**
+ * 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 {
+    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;
+
 /**
  * A Rust-backed [`ExternalSparkSigner`] surfaced to JS as a signer object that
  * can be passed to `connectWithSigner` or `SdkBuilder.newWithSigner`. Produced
@@ -1037,6 +1190,20 @@ export 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}
@@ -1132,6 +1299,19 @@ export class SdkBuilder {
         const ret = wasm.sdkbuilder_withRestChainService(ptr, ptr0, len0, api_type, isLikeNone(credentials) ? 0 : addToExternrefTable0(credentials));
         return SdkBuilder.__wrap(ret);
     }
+    /**
+     * Overrides the session store used to cache auth tokens, replacing the one
+     * the backend provides. Pass any `SessionStore`: for example one that wraps
+     * the backend's own store from `defaultSessionStore` to add at-rest
+     * encryption, which the SDK does not apply itself.
+     * @param {SessionStore} session_store
+     * @returns {SdkBuilder}
+     */
+    withSessionStore(session_store) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.sdkbuilder_withSessionStore(ptr, session_store);
+        return SdkBuilder.__wrap(ret);
+    }
     /**
      * Threads a shared [`WasmSdkContext`] into the builder.
      *
@@ -1174,6 +1354,47 @@ export class SdkBuilder {
 }
 if (Symbol.dispose) SdkBuilder.prototype[Symbol.dispose] = SdkBuilder.prototype.free;
 
+/**
+ * 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 {
+    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;
+
 export class TokenIssuer {
     static __wrap(ptr) {
         const obj = Object.create(TokenIssuer.prototype);
@@ -1324,6 +1545,23 @@ export function connectWithSigner(config, breez_signer, spark_signer, storage_di
     return ret;
 }
 
+/**
+ * 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>}
+ */
+export 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;
+}
+
 /**
  * Builds the Turnkey-backed signers from `config`, then pass
  * `signers.breezSigner` and `signers.sparkSigner` to `connectWithSigner`,
@@ -1336,6 +1574,19 @@ export function createTurnkeySigner(config) {
     return ret;
 }
 
+/**
+ * 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>}
+ */
+export function createTurnkeySigningOnlySigner(config) {
+    const ret = wasm.createTurnkeySigningOnlySigner(config);
+    return ret;
+}
+
 /**
  * @param {Network} network
  * @returns {Config}
@@ -1412,6 +1663,24 @@ export function defaultServerConfig(network) {
     return ret;
 }
 
+/**
+ * The session store the `config`'s backend provides for `identity` (the wallet
+ * identity public key, hex), as a handle to wrap in a `SessionStore` decorator
+ * and pass to `SdkBuilder.withSessionStore`, keeping the backend's persistence.
+ * A typical use is at-rest encryption, which the SDK does not apply itself.
+ * @param {WasmStorageConfig} config
+ * @param {Network} network
+ * @param {string} identity
+ * @returns {Promise<DefaultSessionStore>}
+ */
+export function defaultSessionStore(config, network, identity) {
+    _assertClass(config, WasmStorageConfig);
+    const ptr0 = passStringToWasm0(identity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.defaultSessionStore(config.__wbg_ptr, network, ptr0, len0);
+    return ret;
+}
+
 /**
  * File-based storage rooted at `storageDir` — IndexedDB in the browser,
  * SQLite under Node.js.
@@ -1851,6 +2120,10 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         }, arguments); },
+        __wbg_defaultsessionstore_new: function(arg0) {
+            const ret = DefaultSessionStore.__wrap(arg0);
+            return ret;
+        },
         __wbg_deleteCachedItem_b8fbe3ebea21ed7e: function() { return handleError(function (arg0, arg1, arg2) {
             let deferred0_0;
             let deferred0_1;
@@ -1916,6 +2189,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;
@@ -2184,6 +2469,10 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments); },
+        __wbg_getVerifiedLeafKeys_12405bb5f39ffb61: function() { return handleError(function (arg0) {
+            const ret = arg0.getVerifiedLeafKeys();
+            return ret;
+        }, arguments); },
         __wbg_get_41476db20fef99a8: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
@@ -2629,6 +2918,23 @@ function __wbg_get_imports() {
             const ret = module.require;
             return ret;
         }, arguments); },
+        __wbg_reserveTokenOutputsByOutpoints_a18be5f9fb4ab30a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            let deferred0_0;
+            let deferred0_1;
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                deferred0_0 = arg1;
+                deferred0_1 = arg2;
+                deferred1_0 = arg4;
+                deferred1_1 = arg5;
+                const ret = arg0.reserveTokenOutputsByOutpoints(getStringFromWasm0(arg1, arg2), arg3, getStringFromWasm0(arg4, arg5));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }, arguments); },
         __wbg_reserveTokenOutputs_233990fbd0ce963a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             let deferred0_0;
             let deferred0_1;
@@ -2657,6 +2963,18 @@ function __wbg_get_imports() {
             const ret = SdkBuilder.__wrap(arg0);
             return ret;
         },
+        __wbg_selectTokenOutputs_450f20621013b14d: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg1;
+                deferred0_1 = arg2;
+                const ret = arg0.selectTokenOutputs(getStringFromWasm0(arg1, arg2), arg3, arg4, arg5);
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
         __wbg_send_0edb796d05cd3239: function() { return handleError(function (arg0, arg1, arg2) {
             arg0.send(getStringFromWasm0(arg1, arg2));
         }, arguments); },
@@ -2796,6 +3114,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;
@@ -2820,10 +3150,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;
@@ -2856,6 +3212,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);
@@ -2956,6 +3316,18 @@ function __wbg_get_imports() {
             const ret = arg0.toString();
             return ret;
         },
+        __wbg_tryReserveLeavesByIds_a6433e824993a82f: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg2;
+                deferred0_1 = arg3;
+                const ret = arg0.tryReserveLeavesByIds(arg1, getStringFromWasm0(arg2, arg3));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
         __wbg_tryReserveLeaves_d2cd87cbc2a886d2: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             let deferred0_0;
             let deferred0_1;
@@ -2968,6 +3340,10 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments); },
+        __wbg_trySelectLeaves_ff1aeb7ffc5e4e57: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.trySelectLeaves(arg1);
+            return ret;
+        }, arguments); },
         __wbg_updateDeposit_efb96cf6e6fbe7b7: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             let deferred0_0;
             let deferred0_1;
@@ -3032,61 +3408,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__h21f6855640435575);
             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: 230, 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: 230, 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: 230, 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: 230, 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: 230, 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__h21f6855640435575_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__h21f6855640435575_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__h21f6855640435575_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__h21f6855640435575_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: 392, 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: 421, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
             const ret = makeClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h0fa3f876e31d2a3e);
             return ret;
         },
@@ -3206,36 +3582,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__h21f6855640435575(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h21f6855640435575(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__h21f6855640435575_6(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h21f6855640435575_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__h21f6855640435575_7(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h21f6855640435575_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__h21f6855640435575_8(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h21f6855640435575_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__h21f6855640435575_9(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h21f6855640435575_9(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
@@ -3271,12 +3647,18 @@ const BitcoinChainServiceHandleFinalization = (typeof FinalizationRegistry === '
 const BreezSdkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_breezsdk_free(ptr, 1));
+const DefaultSessionStoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_defaultsessionstore_free(ptr, 1));
 const ExternalBreezSignerHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_externalbreezsignerhandle_free(ptr, 1));
 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));
@@ -3298,6 +3680,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));