@breeztech/breez-sdk-spark 0.13.10-dev → 0.13.12-dev1

package/web/breez_sdk_spark_wasm.js

@@ -1,5 +1,80 @@
 /* @ts-self-types="./breez_sdk_spark_wasm.d.ts" */
 
+/**
+ * Rust-built implementation of the JS `BitcoinChainService` interface.
+ *
+ * Returned by factories like [`new_rest_chain_service`]; users see it as a
+ * `BitcoinChainService` and pass it to `withChainService`. Pass the same
+ * instance to multiple `SdkBuilder`s to share a single underlying HTTP
+ * client (and its connection pool) across SDK instances.
+ */
+export class BitcoinChainServiceHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(BitcoinChainServiceHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        BitcoinChainServiceHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BitcoinChainServiceHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bitcoinchainservicehandle_free(ptr, 0);
+    }
+    /**
+     * @param {string} tx
+     * @returns {Promise<void>}
+     */
+    broadcastTransaction(tx) {
+        const ptr0 = passStringToWasm0(tx, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.bitcoinchainservicehandle_broadcastTransaction(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} address
+     * @returns {Promise<any>}
+     */
+    getAddressUtxos(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.bitcoinchainservicehandle_getAddressUtxos(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} txid
+     * @returns {Promise<any>}
+     */
+    getTransactionHex(txid) {
+        const ptr0 = passStringToWasm0(txid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.bitcoinchainservicehandle_getTransactionHex(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {string} txid
+     * @returns {Promise<any>}
+     */
+    getTransactionStatus(txid) {
+        const ptr0 = passStringToWasm0(txid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.bitcoinchainservicehandle_getTransactionStatus(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    recommendedFees() {
+        const ret = wasm.bitcoinchainservicehandle_recommendedFees(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) BitcoinChainServiceHandle.prototype[Symbol.dispose] = BitcoinChainServiceHandle.prototype.free;
+
 export class BreezSdk {
     static __wrap(ptr) {
         const obj = Object.create(BreezSdk.prototype);
@@ -693,6 +768,30 @@ export class IntoUnderlyingSource {
 }
 if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
 
+/**
+ * A shareable MySQL connection pool. See [`PostgresConnectionPool`](super::postgres_pool::PostgresConnectionPool)
+ * for sharing semantics and lifecycle.
+ */
+export class MysqlConnectionPool {
+    static __wrap(ptr) {
+        const obj = Object.create(MysqlConnectionPool.prototype);
+        obj.__wbg_ptr = ptr;
+        MysqlConnectionPoolFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MysqlConnectionPoolFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mysqlconnectionpool_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) MysqlConnectionPool.prototype[Symbol.dispose] = MysqlConnectionPool.prototype.free;
+
 /**
  * Passkey-based wallet operations using WebAuthn PRF extension.
  *
@@ -774,6 +873,36 @@ export class Passkey {
 }
 if (Symbol.dispose) Passkey.prototype[Symbol.dispose] = Passkey.prototype.free;
 
+/**
+ * A shareable Postgres connection pool.
+ *
+ * Construct via [`create_postgres_connection_pool`] and pass the same handle to multiple
+ * `SdkBuilder`s via `withPostgresConnectionPool` to share connections across SDKs.
+ * Per-tenant scoping is derived from each SDK's seed.
+ *
+ * The pool's lifecycle is controlled by the integrator: it stays alive as
+ * long as any reference is held. `disconnect()` does **not** close the pool.
+ */
+export class PostgresConnectionPool {
+    static __wrap(ptr) {
+        const obj = Object.create(PostgresConnectionPool.prototype);
+        obj.__wbg_ptr = ptr;
+        PostgresConnectionPoolFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PostgresConnectionPoolFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_postgresconnectionpool_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) PostgresConnectionPool.prototype[Symbol.dispose] = PostgresConnectionPool.prototype.free;
+
 export class SdkBuilder {
     static __wrap(ptr) {
         const obj = Object.create(SdkBuilder.prototype);
@@ -864,6 +993,32 @@ export class SdkBuilder {
         const ret = wasm.sdkbuilder_withLnurlClient(ptr, lnurl_client);
         return SdkBuilder.__wrap(ret);
     }
+    /**
+     * **Deprecated.** Call `withMysqlConnectionPool(config)` and `withMysqlConnectionPool(pool)` instead.
+     * @param {MysqlStorageConfig} config
+     * @returns {SdkBuilder}
+     */
+    withMysqlBackend(config) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.sdkbuilder_withMysqlBackend(ptr, config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SdkBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Sets a shared `MySQL` connection pool as the backend for all stores.
+     * Construct via `createMysqlConnectionPool` and pass the same handle to multiple
+     * `SdkBuilder`s to share connections across SDKs.
+     * @param {MysqlConnectionPool} pool
+     * @returns {SdkBuilder}
+     */
+    withMysqlConnectionPool(pool) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(pool, MysqlConnectionPool);
+        const ret = wasm.sdkbuilder_withMysqlConnectionPool(ptr, pool.__wbg_ptr);
+        return SdkBuilder.__wrap(ret);
+    }
     /**
      * @param {PaymentObserver} payment_observer
      * @returns {SdkBuilder}
@@ -874,12 +1029,29 @@ export class SdkBuilder {
         return SdkBuilder.__wrap(ret);
     }
     /**
+     * **Deprecated.** Call `withPostgresConnectionPool(config)` and `withPostgresConnectionPool(pool)` instead.
      * @param {PostgresStorageConfig} config
      * @returns {SdkBuilder}
      */
     withPostgresBackend(config) {
         const ptr = this.__destroy_into_raw();
         const ret = wasm.sdkbuilder_withPostgresBackend(ptr, config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SdkBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Sets a shared `PostgreSQL` connection pool as the backend for all
+     * stores. Construct via `createPostgresConnectionPool` and pass the same handle
+     * to multiple `SdkBuilder`s to share connections across SDKs.
+     * @param {PostgresConnectionPool} pool
+     * @returns {SdkBuilder}
+     */
+    withPostgresConnectionPool(pool) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(pool, PostgresConnectionPool);
+        const ret = wasm.sdkbuilder_withPostgresConnectionPool(ptr, pool.__wbg_ptr);
         return SdkBuilder.__wrap(ret);
     }
     /**
@@ -895,6 +1067,33 @@ export class SdkBuilder {
         const ret = wasm.sdkbuilder_withRestChainService(ptr, ptr0, len0, api_type, isLikeNone(credentials) ? 0 : addToExternrefTable0(credentials));
         return SdkBuilder.__wrap(ret);
     }
+    /**
+     * Sets a custom session manager used to persist authentication sessions.
+     *
+     * Provide a shared, persistent implementation (e.g. backed by `PostgreSQL`
+     * or Redis) to let multiple SDK instances share authentication state and
+     * bootstrap quickly. If not set, an in-memory session manager is used.
+     * @param {SessionManager} session_manager
+     * @returns {SdkBuilder}
+     */
+    withSessionManager(session_manager) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.sdkbuilder_withSessionManager(ptr, session_manager);
+        return SdkBuilder.__wrap(ret);
+    }
+    /**
+     * Reuses a shared SSP connection across SDK instances. Pass the same
+     * manager to every `SdkBuilder` whose SSP traffic should share an
+     * underlying HTTP client.
+     * @param {SspConnectionManager} manager
+     * @returns {SdkBuilder}
+     */
+    withSspConnectionManager(manager) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(manager, SspConnectionManager);
+        const ret = wasm.sdkbuilder_withSspConnectionManager(ptr, manager.__wbg_ptr);
+        return SdkBuilder.__wrap(ret);
+    }
     /**
      * @param {Storage} storage
      * @returns {SdkBuilder}
@@ -907,6 +1106,32 @@ export class SdkBuilder {
 }
 if (Symbol.dispose) SdkBuilder.prototype[Symbol.dispose] = SdkBuilder.prototype.free;
 
+/**
+ * Shared transport for SSP GraphQL traffic across SDK instances.
+ *
+ * All SDK instances built with the same `SspConnectionManager` share a single
+ * underlying HTTP client (and its h2 connection pool) for SSP requests.
+ */
+export class SspConnectionManager {
+    static __wrap(ptr) {
+        const obj = Object.create(SspConnectionManager.prototype);
+        obj.__wbg_ptr = ptr;
+        SspConnectionManagerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SspConnectionManagerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sspconnectionmanager_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) SspConnectionManager.prototype[Symbol.dispose] = SspConnectionManager.prototype.free;
+
 export class TokenIssuer {
     static __wrap(ptr) {
         const obj = Object.create(TokenIssuer.prototype);
@@ -1003,6 +1228,32 @@ export function connectWithSigner(config, signer, storage_dir) {
     return ret;
 }
 
+/**
+ * Creates a shareable MySQL connection pool from the given config.
+ * @param {MysqlStorageConfig} config
+ * @returns {MysqlConnectionPool}
+ */
+export function createMysqlConnectionPool(config) {
+    const ret = wasm.createMysqlConnectionPool(config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return MysqlConnectionPool.__wrap(ret[0]);
+}
+
+/**
+ * Creates a shareable Postgres connection pool from the given config.
+ * @param {PostgresStorageConfig} config
+ * @returns {PostgresConnectionPool}
+ */
+export function createPostgresConnectionPool(config) {
+    const ret = wasm.createPostgresConnectionPool(config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return PostgresConnectionPool.__wrap(ret[0]);
+}
+
 /**
  * @param {Network} network
  * @returns {Config}
@@ -1031,6 +1282,23 @@ export function defaultExternalSigner(mnemonic, passphrase, network, key_set_con
     return DefaultSigner.__wrap(ret[0]);
 }
 
+/**
+ * Creates a default MySQL storage configuration with sensible defaults.
+ *
+ * Default values:
+ * - `maxPoolSize`: 10
+ * - `createTimeoutSecs`: 0 (no timeout)
+ * - `recycleTimeoutSecs`: 10
+ * @param {string} connection_string
+ * @returns {MysqlStorageConfig}
+ */
+export function defaultMysqlStorageConfig(connection_string) {
+    const ptr0 = passStringToWasm0(connection_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.defaultMysqlStorageConfig(ptr0, len0);
+    return ret;
+}
+
 /**
  * Creates a default PostgreSQL storage configuration with sensible defaults.
  *
@@ -1071,6 +1339,38 @@ export function initLogging(logger, filter) {
     return ret;
 }
 
+/**
+ * Constructs a shareable REST-based Bitcoin chain service.
+ *
+ * Pass the returned chain service to multiple `SdkBuilder`s via
+ * `withChainService` to reuse one HTTP client across SDK instances. All
+ * SDKs sharing the chain service must use the same `network`.
+ *
+ * For one-off, non-shared use, prefer `withRestChainService`.
+ * @param {string} url
+ * @param {Network} network
+ * @param {ChainApiType} api_type
+ * @param {Credentials | null} [credentials]
+ * @returns {BitcoinChainService}
+ */
+export function newRestChainService(url, network, api_type, credentials) {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.newRestChainService(ptr0, len0, network, api_type, isLikeNone(credentials) ? 0 : addToExternrefTable0(credentials));
+    return BitcoinChainServiceHandle.__wrap(ret);
+}
+
+/**
+ * @param {string | null} [user_agent]
+ * @returns {SspConnectionManager}
+ */
+export function newSspConnectionManager(user_agent) {
+    var ptr0 = isLikeNone(user_agent) ? 0 : passStringToWasm0(user_agent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.newSspConnectionManager(ptr0, len0);
+    return SspConnectionManager.__wrap(ret);
+}
+
 /**
  * Entry point invoked by JavaScript in a worker.
  * @param {number} ptr
@@ -1334,20 +1634,44 @@ function __wbg_get_imports() {
             const ret = createDefaultStorage(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
         }, arguments); },
+        __wbg_createMysqlPool_8927bff3a28fcef9: function() { return handleError(function (arg0) {
+            const ret = createMysqlPool(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_createMysqlSessionManagerWithPool_e4a41fa210a1c161: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = createMysqlSessionManagerWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
+            return ret;
+        }, arguments); },
+        __wbg_createMysqlStorageWithPool_c92d8cd5f2ca6ade: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = createMysqlStorageWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
+            return ret;
+        }, arguments); },
+        __wbg_createMysqlTokenStoreWithPool_cb308b20dccd4b4e: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = createMysqlTokenStoreWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
+            return ret;
+        }, arguments); },
+        __wbg_createMysqlTreeStoreWithPool_98638c799d6a967c: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = createMysqlTreeStoreWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
+            return ret;
+        }, arguments); },
         __wbg_createPostgresPool_3c396c7ab2f0eab2: function() { return handleError(function (arg0) {
             const ret = createPostgresPool(arg0);
             return ret;
         }, arguments); },
-        __wbg_createPostgresStorageWithPool_9effb8c7315e402a: function() { return handleError(function (arg0, arg1) {
-            const ret = createPostgresStorageWithPool(arg0, arg1);
+        __wbg_createPostgresSessionManagerWithPool_df33d3998bd54e5b: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = createPostgresSessionManagerWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
+            return ret;
+        }, arguments); },
+        __wbg_createPostgresStorageWithPool_3fe1b7ee3ca10589: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = createPostgresStorageWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
             return ret;
         }, arguments); },
-        __wbg_createPostgresTokenStoreWithPool_810f67a7b8eced70: function() { return handleError(function (arg0, arg1) {
-            const ret = createPostgresTokenStoreWithPool(arg0, arg1);
+        __wbg_createPostgresTokenStoreWithPool_ebd4c54228196816: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = createPostgresTokenStoreWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
             return ret;
         }, arguments); },
-        __wbg_createPostgresTreeStoreWithPool_d6f7ade37b9e1ecc: function() { return handleError(function (arg0, arg1) {
-            const ret = createPostgresTreeStoreWithPool(arg0, arg1);
+        __wbg_createPostgresTreeStoreWithPool_6b43821b450142cb: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = createPostgresTreeStoreWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
             return ret;
         }, arguments); },
         __wbg_crypto_38df2bab126b63dc: function(arg0) {
@@ -1478,7 +1802,7 @@ function __wbg_get_imports() {
             const ret = Object.entries(arg0);
             return ret;
         },
-        __wbg_error_ba2b2915aeba36d8: function(arg0, arg1) {
+        __wbg_error_145dadf4216d70bc: function(arg0, arg1) {
             console.error(getStringFromWasm0(arg0, arg1));
         },
         __wbg_fetchFiatCurrencies_8afa0468f01bf013: function() { return handleError(function (arg0) {
@@ -1641,6 +1965,18 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments); },
+        __wbg_getSession_05b1be4bb146adcf: function() { return handleError(function (arg0, arg1, arg2) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg1;
+                deferred0_1 = arg2;
+                const ret = arg0.getSession(getStringFromWasm0(arg1, arg2));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
         __wbg_getStaticDepositPrivateKey_82943f7a0fe1208d: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.getStaticDepositPrivateKey(arg1 >>> 0);
             return ret;
@@ -2155,7 +2491,19 @@ function __wbg_get_imports() {
             const ret = arg0.setLnurlMetadata(v0);
             return ret;
         }, arguments); },
-        __wbg_setTimeout_3b5e32486c12c54e: function(arg0, arg1) {
+        __wbg_setSession_35cb471ae7537391: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg1;
+                deferred0_1 = arg2;
+                const ret = arg0.setSession(getStringFromWasm0(arg1, arg2), arg3);
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
+        __wbg_setTimeout_631eb4eafbc308a9: function(arg0, arg1) {
             globalThis.setTimeout(arg0, arg1);
         },
         __wbg_setTimeout_ef24d2fc3ad97385: function() { return handleError(function (arg0, arg1) {
@@ -2446,103 +2794,108 @@ function __wbg_get_imports() {
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 16, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 403, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 399, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4819aba3eed2db57);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 403, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 399, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4819aba3eed2db57_2);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 403, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 399, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4819aba3eed2db57_3);
             return ret;
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Storage")], shim_idx: 16, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_4);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("SessionManager")], shim_idx: 16, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_4);
             return ret;
         },
         __wbindgen_cast_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TokenStore")], shim_idx: 16, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_5);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Storage")], shim_idx: 16, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_5);
             return ret;
         },
         __wbindgen_cast_0000000000000007: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TreeStore")], shim_idx: 16, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_6);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TokenStore")], shim_idx: 16, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_6);
             return ret;
         },
         __wbindgen_cast_0000000000000008: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 408, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h484cd36e13f37bd7);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TreeStore")], shim_idx: 16, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_7);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 404, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h124479769cd429fd);
             return ret;
         },
-        __wbindgen_cast_0000000000000009: function(arg0) {
+        __wbindgen_cast_000000000000000a: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_000000000000000a: function(arg0) {
+        __wbindgen_cast_000000000000000b: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_000000000000000b: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000c: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_000000000000000c: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000d: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_000000000000000d: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000e: function(arg0, arg1) {
             // Cast intrinsic for `U128 -> Externref`.
             const ret = (BigInt.asUintN(64, arg0) | (BigInt.asUintN(64, arg1) << BigInt(64)));
             return ret;
         },
-        __wbindgen_cast_000000000000000e: function(arg0) {
+        __wbindgen_cast_000000000000000f: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;
         },
-        __wbindgen_cast_000000000000000f: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000010: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("Contact")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000010: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000011: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("ExternalVerifiableSecretShare")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000011: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000012: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("Webhook")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000012: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000013: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
             const ret = v0;
             return ret;
         },
-        __wbindgen_cast_0000000000000013: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000014: function(arg0, arg1) {
             var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 1, 1);
             // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -2565,8 +2918,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h484cd36e13f37bd7(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h484cd36e13f37bd7(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h124479769cd429fd(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h124479769cd429fd(arg0, arg1);
 }
 
 function wasm_bindgen__convert__closures_____invoke__h4819aba3eed2db57(arg0, arg1, arg2) {
@@ -2581,29 +2934,36 @@ function wasm_bindgen__convert__closures_____invoke__h4819aba3eed2db57_3(arg0, a
     wasm.wasm_bindgen__convert__closures_____invoke__h4819aba3eed2db57_3(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_4(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_4(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_4(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_4(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_5(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_5(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_5(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_5(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_6(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_6(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_6(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4fc1641481bc1d84_6(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_7(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c_7(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
@@ -2633,6 +2993,9 @@ const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate
 
 
 const __wbindgen_enum_RequestRedirect = ["follow", "error", "manual"];
+const BitcoinChainServiceHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bitcoinchainservicehandle_free(ptr, 1));
 const BreezSdkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_breezsdk_free(ptr, 1));
@@ -2648,12 +3011,21 @@ const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefin
 const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr, 1));
+const MysqlConnectionPoolFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mysqlconnectionpool_free(ptr, 1));
 const PasskeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_passkey_free(ptr, 1));
+const PostgresConnectionPoolFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_postgresconnectionpool_free(ptr, 1));
 const SdkBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sdkbuilder_free(ptr, 1));
+const SspConnectionManagerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sspconnectionmanager_free(ptr, 1));
 const TokenIssuerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tokenissuer_free(ptr, 1));
@@ -2664,6 +3036,12 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));