@breeztech/breez-sdk-spark 0.15.1 → 0.16.1-dev1

package/bundler/breez_sdk_spark_wasm_bg.js

@@ -107,18 +107,19 @@ export class BreezSdk {
         return ret;
     }
     /**
-     * @param {BuyBitcoinRequest} request
-     * @returns {Promise<BuyBitcoinResponse>}
+     * @param {AuthorizeTransferRequest} request
+     * @returns {Promise<TransferAuthorization>}
      */
-    buyBitcoin(request) {
-        const ret = wasm.breezsdk_buyBitcoin(this.__wbg_ptr, request);
+    authorizeLightningAddressTransfer(request) {
+        const ret = wasm.breezsdk_authorizeLightningAddressTransfer(this.__wbg_ptr, request);
         return ret;
     }
     /**
-     * @returns {Promise<void>}
+     * @param {BuyBitcoinRequest} request
+     * @returns {Promise<BuyBitcoinResponse>}
      */
-    cancelLeafOptimization() {
-        const ret = wasm.breezsdk_cancelLeafOptimization(this.__wbg_ptr);
+    buyBitcoin(request) {
+        const ret = wasm.breezsdk_buyBitcoin(this.__wbg_ptr, request);
         return ret;
     }
     /**
@@ -153,6 +154,14 @@ export class BreezSdk {
         const ret = wasm.breezsdk_claimHtlcPayment(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {ClaimTransferRequest} request
+     * @returns {Promise<LightningAddressInfo>}
+     */
+    claimLightningAddressTransfer(request) {
+        const ret = wasm.breezsdk_claimLightningAddressTransfer(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @param {string} id
      * @returns {Promise<void>}
@@ -193,13 +202,6 @@ export class BreezSdk {
         const ret = wasm.breezsdk_getInfo(this.__wbg_ptr, request);
         return ret;
     }
-    /**
-     * @returns {OptimizationProgress}
-     */
-    getLeafOptimizationProgress() {
-        const ret = wasm.breezsdk_getLeafOptimizationProgress(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * @returns {Promise<LightningAddressInfo | undefined>}
      */
@@ -306,6 +308,14 @@ export class BreezSdk {
         const ret = wasm.breezsdk_lnurlWithdraw(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {OptimizeLeavesRequest} request
+     * @returns {Promise<OptimizeLeavesResponse>}
+     */
+    optimizeLeaves(request) {
+        const ret = wasm.breezsdk_optimizeLeaves(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @param {string} input
      * @returns {Promise<InputType>}
@@ -404,13 +414,6 @@ export class BreezSdk {
         const ret = wasm.breezsdk_signMessage(this.__wbg_ptr, request);
         return ret;
     }
-    /**
-     * @returns {Promise<void>}
-     */
-    startLeafOptimization() {
-        const ret = wasm.breezsdk_startLeafOptimization(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * @param {SyncWalletRequest} request
      * @returns {Promise<SyncWalletResponse>}
@@ -447,33 +450,28 @@ export class BreezSdk {
 if (Symbol.dispose) BreezSdk.prototype[Symbol.dispose] = BreezSdk.prototype.free;
 
 /**
- * A default signer implementation that wraps the core SDK's ExternalSigner.
- * This is returned by `defaultExternalSigner` and can be passed to `connectWithSigner`.
+ * A Rust-backed [`ExternalBreezSigner`] surfaced to JS as a signer object that
+ * can be passed to `connectWithSigner` or `SdkBuilder.newWithSigner`. Produced
+ * by `defaultExternalSigners` (seed) and `createTurnkeySigner` (Turnkey).
+ *
+ * [`ExternalBreezSigner`]: breez_sdk_spark::signer::ExternalBreezSigner
  */
-export class DefaultSigner {
+export class ExternalBreezSignerHandle {
     static __wrap(ptr) {
-        const obj = Object.create(DefaultSigner.prototype);
+        const obj = Object.create(ExternalBreezSignerHandle.prototype);
         obj.__wbg_ptr = ptr;
-        DefaultSignerFinalization.register(obj, obj.__wbg_ptr, obj);
+        ExternalBreezSignerHandleFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        DefaultSignerFinalization.unregister(this);
+        ExternalBreezSignerHandleFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_defaultsigner_free(ptr, 0);
-    }
-    /**
-     * @param {ExternalAggregateFrostRequest} request
-     * @returns {Promise<ExternalFrostSignature>}
-     */
-    aggregateFrost(request) {
-        const ret = wasm.defaultsigner_aggregateFrost(this.__wbg_ptr, request);
-        return ret;
+        wasm.__wbg_externalbreezsignerhandle_free(ptr, 0);
     }
     /**
      * @param {Uint8Array} message
@@ -485,7 +483,7 @@ export class DefaultSigner {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.defaultsigner_decryptEcies(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.externalbreezsignerhandle_decryptEcies(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
     /**
@@ -495,7 +493,7 @@ export class DefaultSigner {
     derivePublicKey(path) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.defaultsigner_derivePublicKey(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.externalbreezsignerhandle_derivePublicKey(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -508,38 +506,7 @@ export class DefaultSigner {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.defaultsigner_encryptEcies(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        return ret;
-    }
-    /**
-     * @param {ExternalEncryptedSecret} private_key
-     * @param {PublicKeyBytes} receiver_public_key
-     * @returns {Promise<Uint8Array>}
-     */
-    encryptPrivateKeyForReceiver(private_key, receiver_public_key) {
-        const ret = wasm.defaultsigner_encryptPrivateKeyForReceiver(this.__wbg_ptr, private_key, receiver_public_key);
-        return ret;
-    }
-    /**
-     * @returns {Promise<ExternalEncryptedSecret>}
-     */
-    generateRandomSecret() {
-        const ret = wasm.defaultsigner_generateRandomSecret(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {Promise<ExternalFrostCommitments>}
-     */
-    generateRandomSigningCommitment() {
-        const ret = wasm.defaultsigner_generateRandomSigningCommitment(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {ExternalTreeNodeId} id
-     * @returns {Promise<PublicKeyBytes>}
-     */
-    getPublicKeyForNode(id) {
-        const ret = wasm.defaultsigner_getPublicKeyForNode(this.__wbg_ptr, id);
+        const ret = wasm.externalbreezsignerhandle_encryptEcies(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
     /**
@@ -552,25 +519,7 @@ export class DefaultSigner {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.defaultsigner_hmacSha256(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        return ret;
-    }
-    /**
-     * @returns {PublicKeyBytes}
-     */
-    identityPublicKey() {
-        const ret = wasm.defaultsigner_identityPublicKey(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {ExternalSecretSource} private_key
-     * @returns {Promise<PublicKeyBytes>}
-     */
-    publicKeyFromSecret(private_key) {
-        const ret = wasm.defaultsigner_publicKeyFromSecret(this.__wbg_ptr, private_key);
+        const ret = wasm.externalbreezsignerhandle_hmacSha256(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
     /**
@@ -581,7 +530,7 @@ export class DefaultSigner {
     signEcdsa(message, path) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.defaultsigner_signEcdsa(this.__wbg_ptr, message, ptr0, len0);
+        const ret = wasm.externalbreezsignerhandle_signEcdsa(this.__wbg_ptr, message, ptr0, len0);
         return ret;
     }
     /**
@@ -592,15 +541,7 @@ export class DefaultSigner {
     signEcdsaRecoverable(message, path) {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.defaultsigner_signEcdsaRecoverable(this.__wbg_ptr, message, ptr0, len0);
-        return ret;
-    }
-    /**
-     * @param {ExternalSignFrostRequest} request
-     * @returns {Promise<ExternalFrostSignatureShare>}
-     */
-    signFrost(request) {
-        const ret = wasm.defaultsigner_signFrost(this.__wbg_ptr, request);
+        const ret = wasm.externalbreezsignerhandle_signEcdsaRecoverable(this.__wbg_ptr, message, ptr0, len0);
         return ret;
     }
     /**
@@ -613,54 +554,205 @@ export class DefaultSigner {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.defaultsigner_signHashSchnorr(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.externalbreezsignerhandle_signHashSchnorr(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
+}
+if (Symbol.dispose) ExternalBreezSignerHandle.prototype[Symbol.dispose] = ExternalBreezSignerHandle.prototype.free;
+
+/**
+ * The two external signers for the SDK's signer-based connect. Returned by
+ * `defaultExternalSigners` (seed) and `createTurnkeySigner` (Turnkey); pass
+ * both halves to `connectWithSigner` or `SdkBuilder.newWithSigner`.
+ */
+export class ExternalSigners {
+    static __wrap(ptr) {
+        const obj = Object.create(ExternalSigners.prototype);
+        obj.__wbg_ptr = ptr;
+        ExternalSignersFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExternalSignersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_externalsigners_free(ptr, 0);
+    }
     /**
-     * @param {ExternalSecretToSplit} secret
-     * @param {number} threshold
-     * @param {number} num_shares
-     * @returns {Promise<ExternalVerifiableSecretShare[]>}
+     * External signer for non-Spark SDK signing (LNURL-auth, sync, message
+     * signing, ECIES).
+     * @returns {ExternalBreezSignerHandle}
      */
-    splitSecretWithProofs(secret, threshold, num_shares) {
-        const ret = wasm.defaultsigner_splitSecretWithProofs(this.__wbg_ptr, secret, threshold, num_shares);
-        return ret;
+    get breezSigner() {
+        const ret = wasm.externalsigners_breezSigner(this.__wbg_ptr);
+        return ExternalBreezSignerHandle.__wrap(ret);
     }
     /**
-     * @param {number} index
-     * @returns {Promise<SecretBytes>}
+     * External high-level Spark signer for the Spark wallet flows.
+     * @returns {ExternalSparkSignerHandle}
      */
-    staticDepositSecret(index) {
-        const ret = wasm.defaultsigner_staticDepositSecret(this.__wbg_ptr, index);
+    get sparkSigner() {
+        const ret = wasm.externalsigners_sparkSigner(this.__wbg_ptr);
+        return ExternalSparkSignerHandle.__wrap(ret);
+    }
+}
+if (Symbol.dispose) ExternalSigners.prototype[Symbol.dispose] = ExternalSigners.prototype.free;
+
+/**
+ * A Rust-backed [`ExternalSparkSigner`] surfaced to JS as a signer object that
+ * can be passed to `connectWithSigner` or `SdkBuilder.newWithSigner`. Produced
+ * by `defaultExternalSigners` (seed) and `createTurnkeySigner` (Turnkey).
+ *
+ * [`ExternalSparkSigner`]: breez_sdk_spark::signer::ExternalSparkSigner
+ */
+export class ExternalSparkSignerHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(ExternalSparkSignerHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        ExternalSparkSignerHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExternalSparkSignerHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_externalsparksignerhandle_free(ptr, 0);
+    }
+    /**
+     * @returns {Promise<PublicKeyBytes>}
+     */
+    getIdentityPublicKey() {
+        const ret = wasm.externalsparksignerhandle_getIdentityPublicKey(this.__wbg_ptr);
         return ret;
     }
     /**
-     * @param {number} index
-     * @returns {Promise<ExternalSecretSource>}
+     * @param {ExternalTreeNodeId} leaf_id
+     * @returns {Promise<PublicKeyBytes>}
      */
-    staticDepositSecretEncrypted(index) {
-        const ret = wasm.defaultsigner_staticDepositSecretEncrypted(this.__wbg_ptr, index);
+    getPublicKeyForLeaf(leaf_id) {
+        const ret = wasm.externalsparksignerhandle_getPublicKeyForLeaf(this.__wbg_ptr, leaf_id);
         return ret;
     }
     /**
      * @param {number} index
      * @returns {Promise<PublicKeyBytes>}
      */
-    staticDepositSigningKey(index) {
-        const ret = wasm.defaultsigner_staticDepositSigningKey(this.__wbg_ptr, index);
+    getStaticDepositPublicKey(index) {
+        const ret = wasm.externalsparksignerhandle_getStaticDepositPublicKey(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * @param {ExternalPrepareClaimRequest} request
+     * @returns {Promise<ExternalPreparedClaim>}
+     */
+    prepareClaim(request) {
+        const ret = wasm.externalsparksignerhandle_prepareClaim(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {ExternalPrepareLightningReceiveRequest} request
+     * @returns {Promise<ExternalPreparedLightningReceive>}
+     */
+    prepareLightningReceive(request) {
+        const ret = wasm.externalsparksignerhandle_prepareLightningReceive(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {ExternalPrepareStaticDepositRequest} request
+     * @returns {Promise<ExternalPreparedStaticDeposit>}
+     */
+    prepareStaticDeposit(request) {
+        const ret = wasm.externalsparksignerhandle_prepareStaticDeposit(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {ExternalPrepareStaticDepositClaimRequest} request
+     * @returns {Promise<ExternalPreparedStaticDepositClaim>}
+     */
+    prepareStaticDepositClaim(request) {
+        const ret = wasm.externalsparksignerhandle_prepareStaticDepositClaim(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {ExternalPrepareTokenTransactionRequest} request
+     * @returns {Promise<ExternalPreparedTokenTransaction>}
+     */
+    prepareTokenTransaction(request) {
+        const ret = wasm.externalsparksignerhandle_prepareTokenTransaction(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {ExternalPrepareTransferRequest} request
+     * @returns {Promise<ExternalPreparedTransfer>}
+     */
+    prepareTransfer(request) {
+        const ret = wasm.externalsparksignerhandle_prepareTransfer(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} challenge
+     * @returns {Promise<EcdsaSignatureBytes>}
+     */
+    signAuthenticationChallenge(challenge) {
+        const ptr0 = passArray8ToWasm0(challenge, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.externalsparksignerhandle_signAuthenticationChallenge(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {ExternalFrostJob[]} jobs
+     * @returns {Promise<ExternalFrostShareResult[]>}
+     */
+    signFrost(jobs) {
+        const ptr0 = passArrayJsValueToWasm0(jobs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.externalsparksignerhandle_signFrost(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} message
+     * @returns {Promise<EcdsaSignatureBytes>}
+     */
+    signMessage(message) {
+        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.externalsparksignerhandle_signMessage(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
-     * @param {ExternalSecretSource} signing_key
-     * @param {ExternalSecretSource} new_signing_key
-     * @returns {Promise<ExternalSecretSource>}
+     * @param {ExternalSignSparkInvoiceRequest} request
+     * @returns {Promise<ExternalSignedSparkInvoice>}
+     */
+    signSparkInvoice(request) {
+        const ret = wasm.externalsparksignerhandle_signSparkInvoice(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {ExternalSignStaticDepositRefundRequest} request
+     * @returns {Promise<ExternalFrostSignature>}
      */
-    subtractSecrets(signing_key, new_signing_key) {
-        const ret = wasm.defaultsigner_subtractSecrets(this.__wbg_ptr, signing_key, new_signing_key);
+    signStaticDepositRefund(request) {
+        const ret = wasm.externalsparksignerhandle_signStaticDepositRefund(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {ExternalStartStaticDepositRefundRequest} request
+     * @returns {Promise<ExternalStartedStaticDepositRefund>}
+     */
+    startStaticDepositRefund(request) {
+        const ret = wasm.externalsparksignerhandle_startStaticDepositRefund(this.__wbg_ptr, request);
         return ret;
     }
 }
-if (Symbol.dispose) DefaultSigner.prototype[Symbol.dispose] = DefaultSigner.prototype.free;
+if (Symbol.dispose) ExternalSparkSignerHandle.prototype[Symbol.dispose] = ExternalSparkSignerHandle.prototype.free;
 
 export class IntoUnderlyingByteSource {
     __destroy_into_raw() {
@@ -774,140 +866,122 @@ 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.
+ * High-level orchestrator that collapses register / sign-in flows
+ * into single calls. See the matching Rust types for full semantics;
+ * the JS surface is a thin wasm-bindgen wrapper.
  */
-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;
-    }
+export class PasskeyClient {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MysqlConnectionPoolFinalization.unregister(this);
+        PasskeyClientFinalization.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.
- *
- * Wraps a `PasskeyPrfProvider` and optional relay configuration to provide
- * wallet derivation and label management via Nostr relays.
- */
-export class Passkey {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        PasskeyFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_passkey_free(ptr, 0);
+        wasm.__wbg_passkeyclient_free(ptr, 0);
     }
     /**
-     * Derive a wallet for a given label.
-     *
-     * Uses the passkey PRF to derive a `Wallet` containing the seed and resolved label.
-     *
-     * @param label - Optional label string (defaults to "Default")
-     * @param {string | null} [label]
-     * @returns {Promise<Wallet>}
+     * One-shot capability probe (PRF support + domain association)
+     * hosts can gate UX on.
+     * @returns {Promise<PasskeyAvailability>}
      */
-    getWallet(label) {
-        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.passkey_getWallet(this.__wbg_ptr, ptr0, len0);
+    checkAvailability() {
+        const ret = wasm.passkeyclient_checkAvailability(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Check if passkey PRF is available on this device.
-     * @returns {Promise<boolean>}
+     * Label sub-object. List / publish labels for this passkey's identity.
+     * @returns {PasskeyLabels}
      */
-    isAvailable() {
-        const ret = wasm.passkey_isAvailable(this.__wbg_ptr);
-        return ret;
+    labels() {
+        const ret = wasm.passkeyclient_labels(this.__wbg_ptr);
+        return PasskeyLabels.__wrap(ret);
     }
     /**
-     * List all labels published to Nostr for this passkey's identity.
-     *
-     * Requires 1 PRF call (for Nostr identity derivation).
-     * @returns {Promise<string[]>}
+     * Create a `PasskeyClient` backed by the supplied `PrfProvider` and
+     * the default Nostr-backed label store. `breezApiKey` enables
+     * authenticated (NIP-42) relay access for label storage; omit for
+     * public relays only.
+     * @param {PrfProvider} prf_provider
+     * @param {string | null} [breez_api_key]
+     * @param {PasskeyConfig | null} [config]
      */
-    listLabels() {
-        const ret = wasm.passkey_listLabels(this.__wbg_ptr);
-        return ret;
+    constructor(prf_provider, breez_api_key, config) {
+        var ptr0 = isLikeNone(breez_api_key) ? 0 : passStringToWasm0(breez_api_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.passkeyclient_new(prf_provider, ptr0, len0, isLikeNone(config) ? 0 : addToExternrefTable0(config));
+        this.__wbg_ptr = ret;
+        PasskeyClientFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Create a new `Passkey` instance.
-     *
-     * @param prfProvider - Platform implementation of passkey PRF operations
-     * @param relayConfig - Optional configuration for Nostr relay connections
-     * @param {PasskeyPrfProvider} prf_provider
-     * @param {NostrRelayConfig | null} [relay_config]
+     * First-time setup. Drives the platform's create-passkey ceremony
+     * then derives the wallet seed in the same PRF assertion ceremony
+     * where the platform supports it.
+     * @param {RegisterRequest} request
+     * @returns {Promise<RegisterResponse>}
      */
-    constructor(prf_provider, relay_config) {
-        const ret = wasm.passkey_new(prf_provider, isLikeNone(relay_config) ? 0 : addToExternrefTable0(relay_config));
-        this.__wbg_ptr = ret;
-        PasskeyFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    register(request) {
+        const ret = wasm.passkeyclient_register(this.__wbg_ptr, request);
+        return ret;
     }
     /**
-     * Publish a label to Nostr relays for this passkey's identity.
-     *
-     * Idempotent: if the label already exists, it is not published again.
-     * Requires 1 PRF call.
-     * @param {string} label
-     * @returns {Promise<void>}
+     * Returning-user sign-in. With `label` set, uses the fast path
+     * (one ceremony, no Nostr round-trip). With `label` omitted,
+     * derives the default-label wallet and discovers the user's
+     * label set in the same ceremony.
+     * @param {SignInRequest} request
+     * @returns {Promise<SignInResponse>}
      */
-    storeLabel(label) {
-        const ptr0 = passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.passkey_storeLabel(this.__wbg_ptr, ptr0, len0);
+    signIn(request) {
+        const ret = wasm.passkeyclient_signIn(this.__wbg_ptr, request);
         return ret;
     }
 }
-if (Symbol.dispose) Passkey.prototype[Symbol.dispose] = Passkey.prototype.free;
+if (Symbol.dispose) PasskeyClient.prototype[Symbol.dispose] = PasskeyClient.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.
+ * Label sub-object surfaced from `PasskeyClient.labels()`.
  */
-export class PostgresConnectionPool {
+export class PasskeyLabels {
     static __wrap(ptr) {
-        const obj = Object.create(PostgresConnectionPool.prototype);
+        const obj = Object.create(PasskeyLabels.prototype);
         obj.__wbg_ptr = ptr;
-        PostgresConnectionPoolFinalization.register(obj, obj.__wbg_ptr, obj);
+        PasskeyLabelsFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PostgresConnectionPoolFinalization.unregister(this);
+        PasskeyLabelsFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_postgresconnectionpool_free(ptr, 0);
+        wasm.__wbg_passkeylabels_free(ptr, 0);
+    }
+    /**
+     * List labels published for this passkey's identity.
+     * @returns {Promise<string[]>}
+     */
+    list() {
+        const ret = wasm.passkeylabels_list(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Idempotently publish `label` for this passkey's identity.
+     * @param {string} label
+     * @returns {Promise<void>}
+     */
+    store(label) {
+        const ptr0 = passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.passkeylabels_store(this.__wbg_ptr, ptr0, len0);
+        return ret;
     }
 }
-if (Symbol.dispose) PostgresConnectionPool.prototype[Symbol.dispose] = PostgresConnectionPool.prototype.free;
+if (Symbol.dispose) PasskeyLabels.prototype[Symbol.dispose] = PasskeyLabels.prototype.free;
 
 export class SdkBuilder {
     static __wrap(ptr) {
@@ -945,11 +1019,21 @@ export class SdkBuilder {
     }
     /**
      * @param {Config} config
-     * @param {ExternalSigner} signer
+     * @param {ExternalBreezSigner} breez_signer
+     * @param {ExternalSparkSigner} spark_signer
+     * @returns {SdkBuilder}
+     */
+    static newWithSigner(config, breez_signer, spark_signer) {
+        const ret = wasm.sdkbuilder_newWithSigner(config, breez_signer, spark_signer);
+        return SdkBuilder.__wrap(ret);
+    }
+    /**
+     * @param {number} account_number
      * @returns {SdkBuilder}
      */
-    static newWithSigner(config, signer) {
-        const ret = wasm.sdkbuilder_newWithSigner(config, signer);
+    withAccountNumber(account_number) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.sdkbuilder_withAccountNumber(ptr, account_number);
         return SdkBuilder.__wrap(ret);
     }
     /**
@@ -981,15 +1065,6 @@ export class SdkBuilder {
         const ret = wasm.sdkbuilder_withFiatService(ptr, fiat_service);
         return SdkBuilder.__wrap(ret);
     }
-    /**
-     * @param {KeySetConfig} config
-     * @returns {SdkBuilder}
-     */
-    withKeySet(config) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.sdkbuilder_withKeySet(ptr, config);
-        return SdkBuilder.__wrap(ret);
-    }
     /**
      * @param {RestClient} lnurl_client
      * @returns {SdkBuilder}
@@ -1000,8 +1075,7 @@ export class SdkBuilder {
         return SdkBuilder.__wrap(ret);
     }
     /**
-     * **Deprecated.** Call `createMysqlConnectionPool(config)` and
-     * `withMysqlConnectionPool(pool)` instead.
+     * **Deprecated.** Use `withStorageBackend(mysqlStorage(config))`.
      * @param {MysqlStorageConfig} config
      * @returns {SdkBuilder}
      */
@@ -1013,20 +1087,6 @@ export class SdkBuilder {
         }
         return SdkBuilder.__wrap(ret[0]);
     }
-    /**
-     * Sets a shared `MySQL` connection pool as the backend for all stores.
-     *
-     * If the same builder also receives a `WasmSdkContext` carrying a MySQL
-     * pool, `build()` returns an error — pick one source.
-     * @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}
@@ -1037,8 +1097,7 @@ export class SdkBuilder {
         return SdkBuilder.__wrap(ret);
     }
     /**
-     * **Deprecated.** Call `createPostgresConnectionPool(config)` and
-     * `withPostgresConnectionPool(pool)` instead.
+     * **Deprecated.** Use `withStorageBackend(postgresStorage(config))`.
      * @param {PostgresStorageConfig} config
      * @returns {SdkBuilder}
      */
@@ -1050,20 +1109,6 @@ export class SdkBuilder {
         }
         return SdkBuilder.__wrap(ret[0]);
     }
-    /**
-     * Sets a shared Postgres connection pool as the backend for all stores.
-     *
-     * If the same builder also receives a `WasmSdkContext` carrying a
-     * Postgres pool, `build()` returns an error — pick one source.
-     * @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);
-    }
     /**
      * @param {string} url
      * @param {ChainApiType} api_type
@@ -1101,6 +1146,21 @@ export class SdkBuilder {
         const ret = wasm.sdkbuilder_withStorage(ptr, storage);
         return SdkBuilder.__wrap(ret);
     }
+    /**
+     * Sets one of the SDK's built-in storage backends.
+     *
+     * Construct the [`WasmStorageConfig`] via `defaultStorage`,
+     * `postgresStorage` or `mysqlStorage`.
+     * @param {WasmStorageConfig} config
+     * @returns {SdkBuilder}
+     */
+    withStorageBackend(config) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(config, WasmStorageConfig);
+        var ptr0 = config.__destroy_into_raw();
+        const ret = wasm.sdkbuilder_withStorageBackend(ptr, ptr0);
+        return SdkBuilder.__wrap(ret);
+    }
 }
 if (Symbol.dispose) SdkBuilder.prototype[Symbol.dispose] = SdkBuilder.prototype.free;
 
@@ -1205,6 +1265,32 @@ export class WasmSdkContext {
 }
 if (Symbol.dispose) WasmSdkContext.prototype[Symbol.dispose] = WasmSdkContext.prototype.free;
 
+/**
+ * Selects one of the SDK's built-in storage backends.
+ *
+ * Construct it via `defaultStorage`, `postgresStorage` or `mysqlStorage` and
+ * pass it to `SdkBuilder.withStorageBackend`.
+ */
+export class WasmStorageConfig {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmStorageConfig.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmStorageConfigFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmStorageConfigFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmstorageconfig_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) WasmStorageConfig.prototype[Symbol.dispose] = WasmStorageConfig.prototype.free;
+
 /**
  * @param {ConnectRequest} request
  * @returns {Promise<BreezSdk>}
@@ -1216,41 +1302,28 @@ export function connect(request) {
 
 /**
  * @param {Config} config
- * @param {ExternalSigner} signer
+ * @param {ExternalBreezSigner} breez_signer
+ * @param {ExternalSparkSigner} spark_signer
  * @param {string} storage_dir
  * @returns {Promise<BreezSdk>}
  */
-export function connectWithSigner(config, signer, storage_dir) {
+export function connectWithSigner(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.connectWithSigner(config, signer, ptr0, len0);
+    const ret = wasm.connectWithSigner(config, breez_signer, spark_signer, ptr0, len0);
     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}
+ * Builds the Turnkey-backed signers from `config`, then pass
+ * `signers.breezSigner` and `signers.sparkSigner` to `connectWithSigner`,
+ * exactly as with any other external signer.
+ * @param {TurnkeyConfig} config
+ * @returns {Promise<ExternalSigners>}
  */
-export function createPostgresConnectionPool(config) {
-    const ret = wasm.createPostgresConnectionPool(config);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return PostgresConnectionPool.__wrap(ret[0]);
+export function createTurnkeySigner(config) {
+    const ret = wasm.createTurnkeySigner(config);
+    return ret;
 }
 
 /**
@@ -1263,22 +1336,26 @@ export function defaultConfig(network) {
 }
 
 /**
+ * Creates the default external signers from a mnemonic phrase.
+ *
+ * Key derivation matches the seed-based connect path: an SDK built either
+ * way from the same mnemonic is the same wallet.
  * @param {string} mnemonic
  * @param {string | null | undefined} passphrase
  * @param {Network} network
- * @param {KeySetConfig | null} [key_set_config]
- * @returns {DefaultSigner}
+ * @param {number | null} [account_number]
+ * @returns {ExternalSigners}
  */
-export function defaultExternalSigner(mnemonic, passphrase, network, key_set_config) {
+export function defaultExternalSigners(mnemonic, passphrase, network, account_number) {
     const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     var ptr1 = isLikeNone(passphrase) ? 0 : passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.defaultExternalSigner(ptr0, len0, ptr1, len1, network, isLikeNone(key_set_config) ? 0 : addToExternrefTable0(key_set_config));
+    const ret = wasm.defaultExternalSigners(ptr0, len0, ptr1, len1, network, isLikeNone(account_number) ? Number.MAX_SAFE_INTEGER : (account_number) >>> 0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return DefaultSigner.__wrap(ret[0]);
+    return ExternalSigners.__wrap(ret[0]);
 }
 
 /**
@@ -1326,9 +1403,19 @@ export function defaultServerConfig(network) {
 }
 
 /**
- * Creates a default external signer from a mnemonic phrase.
- *
- * This creates a signer that can be used with `connectWithSigner` or `SdkBuilder.newWithSigner`.
+ * File-based storage rooted at `storageDir` — IndexedDB in the browser,
+ * SQLite under Node.js.
+ * @param {string} storage_dir
+ * @returns {WasmStorageConfig}
+ */
+export function defaultStorage(storage_dir) {
+    const ptr0 = passStringToWasm0(storage_dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.defaultStorage(ptr0, len0);
+    return WasmStorageConfig.__wrap(ret);
+}
+
+/**
  * @returns {Promise<SparkStatus>}
  */
 export function getSparkStatus() {
@@ -1348,6 +1435,16 @@ export function initLogging(logger, filter) {
     return ret;
 }
 
+/**
+ * `MySQL`-backed storage built from `config`.
+ * @param {MysqlStorageConfig} config
+ * @returns {WasmStorageConfig}
+ */
+export function mysqlStorage(config) {
+    const ret = wasm.mysqlStorage(config);
+    return WasmStorageConfig.__wrap(ret);
+}
+
 /**
  * Constructs a shareable REST-based Bitcoin chain service.
  *
@@ -1379,6 +1476,16 @@ export function newSharedSdkContext(config) {
     return ret;
 }
 
+/**
+ * `PostgreSQL`-backed storage built from `config`.
+ * @param {PostgresStorageConfig} config
+ * @returns {WasmStorageConfig}
+ */
+export function postgresStorage(config) {
+    const ret = wasm.postgresStorage(config);
+    return WasmStorageConfig.__wrap(ret);
+}
+
 /**
  * Entry point invoked by JavaScript in a worker.
  * @param {number} ptr
@@ -1517,13 +1624,19 @@ export function __wbg_addLeaves_96b8c0f05f6b2a00() { return handleError(function
     const ret = arg0.addLeaves(arg1);
     return ret;
 }, arguments); }
-export function __wbg_aggregateFrost_8eb928d3bf25ad91() { return handleError(function (arg0, arg1) {
-    const ret = arg0.aggregateFrost(arg1);
+export function __wbg_afterSend_465a6d26048f7342() { return handleError(function (arg0, arg1, arg2) {
+    var v0 = getArrayJsValueFromWasm0(arg1, arg2).slice();
+    wasm.__wbindgen_free(arg1, arg2 * 4, 4);
+    const ret = arg0.afterSend(v0);
     return ret;
 }, arguments); }
 export function __wbg_append_8df396311184f750() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments); }
+export function __wbg_applyPaymentUpdate_8526d773e5ac8314() { return handleError(function (arg0, arg1) {
+    const ret = arg0.applyPaymentUpdate(arg1);
+    return ret;
+}, arguments); }
 export function __wbg_arrayBuffer_87e3ac06d961f7a0() { return handleError(function (arg0) {
     const ret = arg0.arrayBuffer();
     return ret;
@@ -1647,8 +1760,8 @@ export function __wbg_createMysqlPool_8927bff3a28fcef9() { return handleError(fu
     const ret = createMysqlPool(arg0);
     return ret;
 }, arguments); }
-export function __wbg_createMysqlSessionManagerWithPool_81f4147900a5a954() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-    const ret = createMysqlSessionManagerWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3, arg4 !== 0);
+export function __wbg_createMysqlSessionStoreWithPool_52192c9b2932ff7c() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = createMysqlSessionStoreWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3, arg4 !== 0);
     return ret;
 }, arguments); }
 export function __wbg_createMysqlStorageWithPool_22d23b0d068eae47() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
@@ -1663,12 +1776,16 @@ export function __wbg_createMysqlTreeStoreWithPool_4c6bcff518c7f9c4() { return h
     const ret = createMysqlTreeStoreWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3, arg4, arg5 !== 0);
     return ret;
 }, arguments); }
+export function __wbg_createPasskey_5ceae054474c582a() { return handleError(function (arg0, arg1) {
+    const ret = arg0.createPasskey(arg1);
+    return ret;
+}, arguments); }
 export function __wbg_createPostgresPool_3c396c7ab2f0eab2() { return handleError(function (arg0) {
     const ret = createPostgresPool(arg0);
     return ret;
 }, arguments); }
-export function __wbg_createPostgresSessionManagerWithPool_989bf80d96829c18() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-    const ret = createPostgresSessionManagerWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3, arg4 !== 0);
+export function __wbg_createPostgresSessionStoreWithPool_dd76c7c3517d7bd0() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = createPostgresSessionStoreWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3, arg4 !== 0);
     return ret;
 }, arguments); }
 export function __wbg_createPostgresStorageWithPool_9408116e32ab58f8() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
@@ -1691,6 +1808,20 @@ export function __wbg_data_4a14fad4c5f216c4(arg0) {
     const ret = arg0.data;
     return ret;
 }
+export function __wbg_decryptEcies_ebe426814020926b() { 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.decryptEcies(v0, getStringFromWasm0(arg3, arg4));
+        return ret;
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}, arguments); }
 export function __wbg_deleteCachedItem_b8fbe3ebea21ed7e() { return handleError(function (arg0, arg1, arg2) {
     let deferred0_0;
     let deferred0_1;
@@ -1744,19 +1875,7 @@ export function __wbg_deleteRequest_597243024c6ce08c() { return handleError(func
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
-export function __wbg_derivePrfSeed_7a4ec7d929c9bcca() { return handleError(function (arg0, arg1, arg2) {
-    let deferred0_0;
-    let deferred0_1;
-    try {
-        deferred0_0 = arg1;
-        deferred0_1 = arg2;
-        const ret = arg0.derivePrfSeed(getStringFromWasm0(arg1, arg2));
-        return ret;
-    } finally {
-        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-    }
-}, arguments); }
-export function __wbg_derivePublicKey_bab57284cd981e9a() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_derivePublicKey_1bc53f60dc792488() { return handleError(function (arg0, arg1, arg2) {
     let deferred0_0;
     let deferred0_1;
     try {
@@ -1768,25 +1887,15 @@ export function __wbg_derivePublicKey_bab57284cd981e9a() { return handleError(fu
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
+export function __wbg_deriveSeeds_5c331613e2894c56() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.deriveSeeds(arg1, arg2);
+    return ret;
+}, arguments); }
 export function __wbg_done_b1afd6201ac045e0(arg0) {
     const ret = arg0.done;
     return ret;
 }
-export function __wbg_eciesDecrypt_986d793295625dc9() { 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.eciesDecrypt(v0, getStringFromWasm0(arg3, arg4));
-        return ret;
-    } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-}, arguments); }
-export function __wbg_eciesEncrypt_95486f45d5d74f6a() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_encryptEcies_6a990da1c19d1f7c() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     let deferred1_0;
     let deferred1_1;
     try {
@@ -1794,16 +1903,12 @@ export function __wbg_eciesEncrypt_95486f45d5d74f6a() { return handleError(funct
         wasm.__wbindgen_free(arg1, arg2 * 1, 1);
         deferred1_0 = arg3;
         deferred1_1 = arg4;
-        const ret = arg0.eciesEncrypt(v0, getStringFromWasm0(arg3, arg4));
+        const ret = arg0.encryptEcies(v0, getStringFromWasm0(arg3, arg4));
         return ret;
     } finally {
         wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }, arguments); }
-export function __wbg_encryptPrivateKeyForReceiver_a5414ece502e2eec() { return handleError(function (arg0, arg1, arg2) {
-    const ret = arg0.encryptPrivateKeyForReceiver(arg1, arg2);
-    return ret;
-}, arguments); }
 export function __wbg_enqueue_6c7cd543c0f3828e() { return handleError(function (arg0, arg1) {
     arg0.enqueue(arg1);
 }, arguments); }
@@ -1814,6 +1919,10 @@ export function __wbg_entries_bb9843ba73dc70d6(arg0) {
 export function __wbg_error_145dadf4216d70bc(arg0, arg1) {
     console.error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg_externalsigners_new(arg0) {
+    const ret = ExternalSigners.__wrap(arg0);
+    return ret;
+}
 export function __wbg_fetchFiatCurrencies_8afa0468f01bf013() { return handleError(function (arg0) {
     const ret = arg0.fetchFiatCurrencies();
     return ret;
@@ -1862,14 +1971,10 @@ export function __wbg_finalizeReservation_aa324ddf4b195930() { return handleErro
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
-export function __wbg_generateFrostSigningCommitments_1e8b83b2bed675c9() { return handleError(function (arg0) {
-    const ret = arg0.generateFrostSigningCommitments();
+export function __wbg_from_ff141b1e4c69b979(arg0) {
+    const ret = Array.from(arg0);
     return ret;
-}, arguments); }
-export function __wbg_generateRandomSecret_432432761a2594b7() { return handleError(function (arg0) {
-    const ret = arg0.generateRandomSecret();
-    return ret;
-}, arguments); }
+}
 export function __wbg_getAddressUtxos_9526b6d8078b867e() { return handleError(function (arg0, arg1, arg2) {
     let deferred0_0;
     let deferred0_1;
@@ -1910,6 +2015,10 @@ export function __wbg_getContact_35b5c6f2fa25cf9e() { return handleError(functio
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
+export function __wbg_getIdentityPublicKey_c6fcd87d66ed6927() { return handleError(function (arg0) {
+    const ret = arg0.getIdentityPublicKey();
+    return ret;
+}, arguments); }
 export function __wbg_getLeaves_5259dc2b9de80ff0() { return handleError(function (arg0) {
     const ret = arg0.getLeaves();
     return ret;
@@ -1944,12 +2053,8 @@ export function __wbg_getPaymentsByParentIds_7ab066452766ae6d() { return handleE
     const ret = arg0.getPaymentsByParentIds(v0);
     return ret;
 }, arguments); }
-export function __wbg_getPublicKeyForNode_1c1b34ec571148c2() { return handleError(function (arg0, arg1) {
-    const ret = arg0.getPublicKeyForNode(arg1);
-    return ret;
-}, arguments); }
-export function __wbg_getPublicKeyFromSecretSource_cecb0b3d2ce521bd() { return handleError(function (arg0, arg1) {
-    const ret = arg0.getPublicKeyFromSecretSource(arg1);
+export function __wbg_getPublicKeyForLeaf_9826724c9b0c3963() { return handleError(function (arg0, arg1) {
+    const ret = arg0.getPublicKeyForLeaf(arg1);
     return ret;
 }, arguments); }
 export function __wbg_getRandomValues_c44a50d8cfdaebeb() { return handleError(function (arg0, arg1) {
@@ -1974,7 +2079,7 @@ 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) {
+export function __wbg_getSession_95998cc236a30653() { return handleError(function (arg0, arg1, arg2) {
     let deferred0_0;
     let deferred0_1;
     try {
@@ -1986,18 +2091,10 @@ export function __wbg_getSession_05b1be4bb146adcf() { return handleError(functio
         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;
-}, arguments); }
-export function __wbg_getStaticDepositPublicKey_8424ddc7bb238008() { return handleError(function (arg0, arg1) {
+export function __wbg_getStaticDepositPublicKey_9c7c893612c4c53f() { return handleError(function (arg0, arg1) {
     const ret = arg0.getStaticDepositPublicKey(arg1 >>> 0);
     return ret;
 }, arguments); }
-export function __wbg_getStaticDepositSecretSource_86007c41c79d2bea() { return handleError(function (arg0, arg1) {
-    const ret = arg0.getStaticDepositSecretSource(arg1 >>> 0);
-    return ret;
-}, arguments); }
 export function __wbg_getTokenBalances_b788cda26e92f342() { return handleError(function (arg0) {
     const ret = arg0.getTokenBalances();
     return ret;
@@ -2030,6 +2127,10 @@ export function __wbg_getTransactionStatus_32c49e1985e35d63() { return handleErr
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
+export function __wbg_get_41476db20fef99a8() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
 export function __wbg_get_652f640b3b0b6e3e(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
@@ -2062,7 +2163,7 @@ export function __wbg_headers_de17f740bce997ae(arg0) {
     const ret = arg0.headers;
     return ret;
 }
-export function __wbg_hmacSha256_44b56787dc85796b() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_hmacSha256_04164bea6bd3c7d4() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     let deferred1_0;
     let deferred1_1;
     try {
@@ -2076,10 +2177,6 @@ export function __wbg_hmacSha256_44b56787dc85796b() { return handleError(functio
         wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }, arguments); }
-export function __wbg_identityPublicKey_157f9d906d49e5c4() { return handleError(function (arg0) {
-    const ret = arg0.identityPublicKey();
-    return ret;
-}, arguments); }
 export function __wbg_insertContact_cc39397cb8e88ff8() { return handleError(function (arg0, arg1) {
     const ret = arg0.insertContact(arg1);
     return ret;
@@ -2096,10 +2193,6 @@ export function __wbg_insertPaymentMetadata_0ce664b21d71c9f8() { return handleEr
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
-export function __wbg_insertPayment_830c37c6efef1f8a() { return handleError(function (arg0, arg1) {
-    const ret = arg0.insertPayment(arg1);
-    return ret;
-}, arguments); }
 export function __wbg_instanceof_ArrayBuffer_eab9f28fbec23477(arg0) {
     let result;
     try {
@@ -2184,14 +2277,14 @@ export function __wbg_isArray_c6c6ef8308995bcf(arg0) {
     const ret = Array.isArray(arg0);
     return ret;
 }
-export function __wbg_isPrfAvailable_f77f283e48e966e1() { return handleError(function (arg0) {
-    const ret = arg0.isPrfAvailable();
-    return ret;
-}, arguments); }
 export function __wbg_isSafeInteger_3c56c421a5b4cce4(arg0) {
     const ret = Number.isSafeInteger(arg0);
     return ret;
 }
+export function __wbg_isSupported_0fab0220495a1089() { return handleError(function (arg0) {
+    const ret = arg0.isSupported();
+    return ret;
+}, arguments); }
 export function __wbg_iterator_9d68985a1d096fc2() {
     const ret = Symbol.iterator;
     return ret;
@@ -2392,6 +2485,30 @@ export function __wbg_postRequest_b7e02f7ec4d8b99b() { return handleError(functi
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
+export function __wbg_prepareClaim_1286899715876e7d() { return handleError(function (arg0, arg1) {
+    const ret = arg0.prepareClaim(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_prepareLightningReceive_fe5b5a46a5d5d976() { return handleError(function (arg0, arg1) {
+    const ret = arg0.prepareLightningReceive(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_prepareStaticDepositClaim_2aac4f9634448525() { return handleError(function (arg0, arg1) {
+    const ret = arg0.prepareStaticDepositClaim(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_prepareStaticDeposit_66175a4078320749() { return handleError(function (arg0, arg1) {
+    const ret = arg0.prepareStaticDeposit(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_prepareTokenTransaction_d2e097f1363077c0() { return handleError(function (arg0, arg1) {
+    const ret = arg0.prepareTokenTransaction(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_prepareTransfer_f1fd01fccd18c85b() { return handleError(function (arg0, arg1) {
+    const ret = arg0.prepareTransfer(arg1);
+    return ret;
+}, arguments); }
 export function __wbg_process_44c7a14e11e9f69e(arg0) {
     const ret = arg0.process;
     return ret;
@@ -2399,6 +2516,10 @@ export function __wbg_process_44c7a14e11e9f69e(arg0) {
 export function __wbg_prototypesetcall_fd4050e806e1d519(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 }
+export function __wbg_push_60a5366c0bb22a7d(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+}
 export function __wbg_queueMicrotask_40ac6ffc2848ba77(arg0) {
     queueMicrotask(arg0);
 }
@@ -2496,7 +2617,7 @@ 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) {
+export function __wbg_setSession_86d7fef1f452677c() { return handleError(function (arg0, arg1, arg2, arg3) {
     let deferred0_0;
     let deferred0_1;
     try {
@@ -2588,7 +2709,13 @@ export function __wbg_set_referrer_policy_5afdd37afd73c769(arg0, arg1) {
 export function __wbg_set_signal_8c5cf4c3b27bd8a8(arg0, arg1) {
     arg0.signal = arg1;
 }
-export function __wbg_signEcdsaRecoverable_e1e9c5e2c8ec869f() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_signAuthenticationChallenge_e2ea9cf87c76a6de() { return handleError(function (arg0, arg1, arg2) {
+    var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+    wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+    const ret = arg0.signAuthenticationChallenge(v0);
+    return ret;
+}, arguments); }
+export function __wbg_signEcdsaRecoverable_978c5526e66a433b() { return handleError(function (arg0, arg1, arg2, arg3) {
     let deferred0_0;
     let deferred0_1;
     try {
@@ -2600,7 +2727,7 @@ export function __wbg_signEcdsaRecoverable_e1e9c5e2c8ec869f() { return handleErr
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
-export function __wbg_signEcdsa_99eb88e7d9907236() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_signEcdsa_1947a1a2c8f39a16() { return handleError(function (arg0, arg1, arg2, arg3) {
     let deferred0_0;
     let deferred0_1;
     try {
@@ -2612,11 +2739,11 @@ export function __wbg_signEcdsa_99eb88e7d9907236() { return handleError(function
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
 }, arguments); }
-export function __wbg_signFrost_df3d96ac20619b95() { return handleError(function (arg0, arg1) {
+export function __wbg_signFrost_08951e01d00d4b1c() { return handleError(function (arg0, arg1) {
     const ret = arg0.signFrost(arg1);
     return ret;
 }, arguments); }
-export function __wbg_signHashSchnorr_33c182cb4c2323d5() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_signHashSchnorr_fc8afda9a7ee021a() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     let deferred1_0;
     let deferred1_1;
     try {
@@ -2630,12 +2757,26 @@ export function __wbg_signHashSchnorr_33c182cb4c2323d5() { return handleError(fu
         wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }, arguments); }
+export function __wbg_signMessage_80ec0b0dfc7f00ee() { return handleError(function (arg0, arg1, arg2) {
+    var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+    wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+    const ret = arg0.signMessage(v0);
+    return ret;
+}, arguments); }
+export function __wbg_signSparkInvoice_cca6c7f35b5e85d2() { return handleError(function (arg0, arg1) {
+    const ret = arg0.signSparkInvoice(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_signStaticDepositRefund_3a6fb4e71a15bebd() { return handleError(function (arg0, arg1) {
+    const ret = arg0.signStaticDepositRefund(arg1);
+    return ret;
+}, arguments); }
 export function __wbg_signal_4643ce883b92b553(arg0) {
     const ret = arg0.signal;
     return ret;
 }
-export function __wbg_splitSecretWithProofs_c9d51158a14af659() { return handleError(function (arg0, arg1, arg2, arg3) {
-    const ret = arg0.splitSecretWithProofs(arg1, arg2 >>> 0, arg3 >>> 0);
+export function __wbg_startStaticDepositRefund_5b591bbea22aa0d2() { return handleError(function (arg0, arg1) {
+    const ret = arg0.startStaticDepositRefund(arg1);
     return ret;
 }, arguments); }
 export function __wbg_static_accessor_GLOBAL_THIS_1c7f1bd6c6941fdb() {
@@ -2666,10 +2807,6 @@ export function __wbg_subarray_fbe3cef290e1fa43(arg0, arg1, arg2) {
     const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
     return ret;
 }
-export function __wbg_subtractPrivateKeys_c66265ac85e781b7() { return handleError(function (arg0, arg1, arg2) {
-    const ret = arg0.subtractPrivateKeys(arg1, arg2);
-    return ret;
-}, arguments); }
 export function __wbg_syncAddOutgoingChange_69db2a1430cbd55a() { return handleError(function (arg0, arg1) {
     const ret = arg0.syncAddOutgoingChange(arg1);
     return ret;
@@ -2806,48 +2943,48 @@ export function __wbg_wasmsdkcontext_new(arg0) {
     return ret;
 }
 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__h013a98c02f3b4b21);
+    // 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__h4bd7a023e323559c);
     return ret;
 }
 export function __wbindgen_cast_0000000000000002(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: 348, 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: 403, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 348, 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: 403, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 348, 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("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__h013a98c02f3b4b21_4);
+    // 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__h4bd7a023e323559c_4);
     return ret;
 }
 export function __wbindgen_cast_0000000000000006(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__h013a98c02f3b4b21_5);
+    // 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__h4bd7a023e323559c_5);
     return ret;
 }
 export function __wbindgen_cast_0000000000000007(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__h013a98c02f3b4b21_6);
+    // 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__h4bd7a023e323559c_6);
     return ret;
 }
 export function __wbindgen_cast_0000000000000008(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__h013a98c02f3b4b21_7);
+    // 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__h4bd7a023e323559c_7);
     return ret;
 }
 export function __wbindgen_cast_0000000000000009(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__h124479769cd429fd);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 353, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h484cd36e13f37bd7);
     return ret;
 }
 export function __wbindgen_cast_000000000000000a(arg0) {
@@ -2890,7 +3027,7 @@ 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`.
+    // Cast intrinsic for `Vector(NamedExternref("ExternalFrostShareResult")) -> Externref`.
     const ret = v0;
     return ret;
 }
@@ -2924,8 +3061,8 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
-function wasm_bindgen__convert__closures_____invoke__h124479769cd429fd(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h124479769cd429fd(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h484cd36e13f37bd7(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h484cd36e13f37bd7(arg0, arg1);
 }
 
 function wasm_bindgen__convert__closures_____invoke__h4819aba3eed2db57(arg0, arg1, arg2) {
@@ -2940,36 +3077,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__h013a98c02f3b4b21(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21_4(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21_4(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c_4(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c_4(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21_5(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21_5(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c_5(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c_5(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21_6(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21_6(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c_6(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c_6(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21_7(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h013a98c02f3b4b21_7(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c_7(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h4bd7a023e323559c_7(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
@@ -3005,9 +3142,15 @@ const BitcoinChainServiceHandleFinalization = (typeof FinalizationRegistry === '
 const BreezSdkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_breezsdk_free(ptr, 1));
-const DefaultSignerFinalization = (typeof FinalizationRegistry === 'undefined')
+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 ExternalSparkSignerHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_defaultsigner_free(ptr, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_externalsparksignerhandle_free(ptr, 1));
 const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr, 1));
@@ -3017,15 +3160,12 @@ 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')
+const PasskeyClientFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_mysqlconnectionpool_free(ptr, 1));
-const PasskeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    : new FinalizationRegistry(ptr => wasm.__wbg_passkeyclient_free(ptr, 1));
+const PasskeyLabelsFinalization = (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));
+    : new FinalizationRegistry(ptr => wasm.__wbg_passkeylabels_free(ptr, 1));
 const SdkBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sdkbuilder_free(ptr, 1));
@@ -3035,6 +3175,9 @@ const TokenIssuerFinalization = (typeof FinalizationRegistry === 'undefined')
 const WasmSdkContextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmsdkcontext_free(ptr, 1));
+const WasmStorageConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmstorageconfig_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -3201,6 +3344,16 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);