@breeztech/breez-sdk-spark 0.13.11-dev1 → 0.13.12-dev1

package/bundler/breez_sdk_spark_wasm_bg.js

@@ -1,3 +1,78 @@
+/**
+ * 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);
@@ -691,6 +766,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.
  *
@@ -772,6 +871,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);
@@ -863,12 +992,29 @@ export class SdkBuilder {
         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);
     }
     /**
@@ -881,12 +1027,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);
     }
     /**
@@ -902,6 +1065,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}
@@ -914,6 +1104,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);
@@ -1010,6 +1226,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}
@@ -1095,6 +1337,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
@@ -1359,6 +1633,10 @@ export function __wbg_createMysqlPool_8927bff3a28fcef9() { return handleError(fu
     const ret = createMysqlPool(arg0);
     return ret;
 }, arguments); }
+export function __wbg_createMysqlSessionManagerWithPool_e4a41fa210a1c161() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = createMysqlSessionManagerWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
+    return ret;
+}, arguments); }
 export function __wbg_createMysqlStorageWithPool_c92d8cd5f2ca6ade() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = createMysqlStorageWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
     return ret;
@@ -1375,6 +1653,10 @@ export function __wbg_createPostgresPool_3c396c7ab2f0eab2() { return handleError
     const ret = createPostgresPool(arg0);
     return ret;
 }, arguments); }
+export function __wbg_createPostgresSessionManagerWithPool_df33d3998bd54e5b() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = createPostgresSessionManagerWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
+    return ret;
+}, arguments); }
 export function __wbg_createPostgresStorageWithPool_3fe1b7ee3ca10589() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = createPostgresStorageWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3);
     return ret;
@@ -1678,6 +1960,18 @@ export function __wbg_getRequest_9153d27d6c51b5c7() { return handleError(functio
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
+export function __wbg_getSession_05b1be4bb146adcf() { 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); }
 export function __wbg_getStaticDepositPrivateKey_82943f7a0fe1208d() { return handleError(function (arg0, arg1) {
     const ret = arg0.getStaticDepositPrivateKey(arg1 >>> 0);
     return ret;
@@ -2192,6 +2486,18 @@ export function __wbg_setLnurlMetadata_084b50d8b878f93f() { return handleError(f
     const ret = arg0.setLnurlMetadata(v0);
     return ret;
 }, arguments); }
+export function __wbg_setSession_35cb471ae7537391() { 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); }
 export function __wbg_setTimeout_631eb4eafbc308a9(arg0, arg1) {
     globalThis.setTimeout(arg0, arg1);
 }
@@ -2483,103 +2789,108 @@ export function __wbg_wasClean_92b4133f985dfae0(arg0) {
 }
 export function __wbindgen_cast_0000000000000001(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__h27d08ee20b1285c7);
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h459c42c6ffe5f52c);
     return ret;
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 401, 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;
 }
 export function __wbindgen_cast_0000000000000003(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 401, 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;
 }
 export function __wbindgen_cast_0000000000000004(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 401, 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;
 }
 export function __wbindgen_cast_0000000000000005(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__h27d08ee20b1285c7_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;
 }
 export function __wbindgen_cast_0000000000000006(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__h27d08ee20b1285c7_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;
 }
 export function __wbindgen_cast_0000000000000007(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__h27d08ee20b1285c7_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;
 }
 export function __wbindgen_cast_0000000000000008(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 406, 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;
+}
+export function __wbindgen_cast_0000000000000009(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;
 }
-export function __wbindgen_cast_0000000000000009(arg0) {
+export function __wbindgen_cast_000000000000000a(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;
     return ret;
 }
-export function __wbindgen_cast_000000000000000a(arg0) {
+export function __wbindgen_cast_000000000000000b(arg0) {
     // Cast intrinsic for `I64 -> Externref`.
     const ret = arg0;
     return ret;
 }
-export function __wbindgen_cast_000000000000000b(arg0, arg1) {
+export function __wbindgen_cast_000000000000000c(arg0, arg1) {
     // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
     const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;
 }
-export function __wbindgen_cast_000000000000000c(arg0, arg1) {
+export function __wbindgen_cast_000000000000000d(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 }
-export function __wbindgen_cast_000000000000000d(arg0, arg1) {
+export function __wbindgen_cast_000000000000000e(arg0, arg1) {
     // Cast intrinsic for `U128 -> Externref`.
     const ret = (BigInt.asUintN(64, arg0) | (BigInt.asUintN(64, arg1) << BigInt(64)));
     return ret;
 }
-export function __wbindgen_cast_000000000000000e(arg0) {
+export function __wbindgen_cast_000000000000000f(arg0) {
     // Cast intrinsic for `U64 -> Externref`.
     const ret = BigInt.asUintN(64, arg0);
     return ret;
 }
-export function __wbindgen_cast_000000000000000f(arg0, arg1) {
+export function __wbindgen_cast_0000000000000010(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;
 }
-export function __wbindgen_cast_0000000000000010(arg0, arg1) {
+export function __wbindgen_cast_0000000000000011(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;
 }
-export function __wbindgen_cast_0000000000000011(arg0, arg1) {
+export function __wbindgen_cast_0000000000000012(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;
 }
-export function __wbindgen_cast_0000000000000012(arg0, arg1) {
+export function __wbindgen_cast_0000000000000013(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;
 }
-export function __wbindgen_cast_0000000000000013(arg0, arg1) {
+export function __wbindgen_cast_0000000000000014(arg0, arg1) {
     var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_free(arg0, arg1 * 1, 1);
     // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -2595,8 +2906,8 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
-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) {
@@ -2611,29 +2922,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__h27d08ee20b1285c7(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h27d08ee20b1285c7(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__h27d08ee20b1285c7_4(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h27d08ee20b1285c7_4(arg0, arg1, arg2);
+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__h27d08ee20b1285c7_5(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h27d08ee20b1285c7_5(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__h27d08ee20b1285c7_6(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h27d08ee20b1285c7_6(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__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]);
     }
@@ -2663,6 +2981,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));
@@ -2678,12 +2999,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));
@@ -2694,6 +3024,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));