@breeztech/breez-sdk-spark-react-native 0.13.12-dev1 → 0.15.0

package/src/generated/breez_sdk_spark.ts

@@ -248,6 +248,54 @@ export function defaultExternalSigner(
     )
   );
 }
+/**
+ * Builds a [`Config`] suitable for multi-tenant server-mode deployments.
+ *
+ * This preset returns the same configuration as [`default_config`] with
+ * [`background_tasks_enabled`](Config::background_tasks_enabled) set to
+ * `false`. In server mode, the SDK is treated as a library: the host
+ * orchestrates sync, claiming, and event delivery (typically via webhooks)
+ * explicitly, so an ephemeral SDK instance stays cheap and predictable.
+ *
+ * Config fields whose background services are gated off are reset to their
+ * inactive shape: `real_time_sync_server_url` is set to `None`, and both
+ * `leaf_optimization_config.auto_enabled` and
+ * `token_optimization_config.auto_enabled` are set to `false`. The SDK
+ * rejects builds where `background_tasks_enabled` is `false` and any of
+ * those fields is left in its active shape, so flip the flag via this
+ * helper rather than by hand.
+ *
+ * Explicit operations (`sync_wallet`, `claim_deposit`,
+ * `list_unclaimed_deposits`, `refund_deposit`,
+ * `refund_pending_conversions`, etc.) continue to work and are the intended
+ * entry points in this mode.
+ *
+ * Stable Balance is not supported in this mode because its conversion worker
+ * is a background service.
+ *
+ * One-time setup that the SDK normally applies automatically — notably
+ * `private_enabled_default` — is NOT applied in this mode. Drive setup
+ * explicitly via `update_user_settings` (and any other relevant APIs) so
+ * ephemeral per-request SDK instances incur no implicit setup overhead.
+ *
+ * `get_info` reads balance directly from the spark wallet in this mode
+ * rather than from the background-maintained storage cache, so balance
+ * reflects the latest local sync and `ensure_synced=true` is rejected with
+ * an invalid-input error
+ */
+export function defaultServerConfig(network: Network): Config {
+  return FfiConverterTypeConfig.lift(
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_func_default_server_config(
+          FfiConverterTypeNetwork.lower(network),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    )
+  );
+}
 /**
  * Fetches the current status of Spark network services relevant to the SDK.
  *
@@ -306,29 +354,6 @@ export function initLogging(
     /*liftString:*/ FfiConverterString.lift
   );
 }
-/**
- * Creates a new shareable [`ConnectionManager`].
- *
- * `connections_per_operator` controls per-operator connection pooling:
- * `None` keeps a single connection per operator (suitable for almost every
- * deployment); `Some(n)` opens `n` connections per operator and balances
- * requests across them.
- */
-export function newConnectionManager(
-  connectionsPerOperator: /*u32*/ number | undefined
-): ConnectionManagerInterface {
-  return FfiConverterTypeConnectionManager.lift(
-    uniffiCaller.rustCall(
-      /*caller:*/ (callStatus) => {
-        return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_func_new_connection_manager(
-          FfiConverterOptionalUInt32.lower(connectionsPerOperator),
-          callStatus
-        );
-      },
-      /*liftString:*/ FfiConverterString.lift
-    )
-  );
-}
 /**
  * Constructs a shareable REST-based [`BitcoinChainService`].
  *
@@ -340,49 +365,90 @@ export function newConnectionManager(
  * For one-off, non-shared use, prefer
  * [`SdkBuilder::with_rest_chain_service`](crate::SdkBuilder::with_rest_chain_service).
  */
-export function newRestChainService(
+export async function newRestChainService(
   url: string,
   network: Network,
   apiType: ChainApiType,
-  credentials: Credentials | undefined
-): BitcoinChainService {
-  return FfiConverterTypeBitcoinChainService.lift(
-    uniffiCaller.rustCall(
-      /*caller:*/ (callStatus) => {
+  credentials: Credentials | undefined,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<BitcoinChainService> {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
         return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_func_new_rest_chain_service(
           FfiConverterString.lower(url),
           FfiConverterTypeNetwork.lower(network),
           FfiConverterTypeChainApiType.lower(apiType),
-          FfiConverterOptionalTypeCredentials.lower(credentials),
-          callStatus
+          FfiConverterOptionalTypeCredentials.lower(credentials)
         );
       },
-      /*liftString:*/ FfiConverterString.lift
-    )
-  );
+      /*pollFunc:*/ nativeModule()
+        .ubrn_ffi_breez_sdk_spark_rust_future_poll_pointer,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_breez_sdk_spark_rust_future_cancel_pointer,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_breez_sdk_spark_rust_future_complete_pointer,
+      /*freeFunc:*/ nativeModule()
+        .ubrn_ffi_breez_sdk_spark_rust_future_free_pointer,
+      /*liftFunc:*/ FfiConverterTypeBitcoinChainService.lift.bind(
+        FfiConverterTypeBitcoinChainService
+      ),
+      /*liftString:*/ FfiConverterString.lift,
+      /*asyncOpts:*/ asyncOpts_
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
 }
 /**
- * Construct a new shared SSP connection manager.
+ * Constructs an [`SdkContext`] from a `SdkContextConfig`.
  *
- * Pass the returned `Arc<SspConnectionManager>` to
- * [`SdkBuilder::with_ssp_connection_manager`](crate::SdkBuilder::with_ssp_connection_manager)
- * when building each SDK instance that should share the underlying HTTP
- * connection pool.
- */
-export function newSspConnectionManager(
-  userAgent: string | undefined
-): SspConnectionManagerInterface {
-  return FfiConverterTypeSspConnectionManager.lift(
-    uniffiCaller.rustCall(
-      /*caller:*/ (callStatus) => {
-        return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_func_new_ssp_connection_manager(
-          FfiConverterOptionalString.lower(userAgent),
-          callStatus
+ * The returned `Arc` is cheap to clone and can back many SDK instances.
+ * `SdkContextConfig::new(network)` yields an in-memory, single-tenant setup;
+ * supply a DB config to back the SDKs with a shared `PostgreSQL` or `MySQL`
+ * pool.
+ */
+export async function newSharedSdkContext(
+  config: SdkContextConfig,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<SdkContextInterface> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_func_new_shared_sdk_context(
+          FfiConverterTypeSdkContextConfig.lower(config)
         );
       },
-      /*liftString:*/ FfiConverterString.lift
-    )
-  );
+      /*pollFunc:*/ nativeModule()
+        .ubrn_ffi_breez_sdk_spark_rust_future_poll_pointer,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_breez_sdk_spark_rust_future_cancel_pointer,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_breez_sdk_spark_rust_future_complete_pointer,
+      /*freeFunc:*/ nativeModule()
+        .ubrn_ffi_breez_sdk_spark_rust_future_free_pointer,
+      /*liftFunc:*/ FfiConverterTypeSdkContext.lift.bind(
+        FfiConverterTypeSdkContext
+      ),
+      /*liftString:*/ FfiConverterString.lift,
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSdkError.lift.bind(
+        FfiConverterTypeSdkError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
 }
 
 /**
@@ -2126,8 +2192,15 @@ export type Config = {
   /**
    * Whether the Spark private mode is enabled by default.
    *
-   * If set to true, the Spark private mode will be enabled on the first initialization of the SDK.
-   * If set to false, no changes will be made to the Spark private mode.
+   * If set to true, the Spark private mode will be enabled on the first
+   * initialization of the SDK. If set to false, no changes will be made
+   * to the Spark private mode.
+   *
+   * This default is only auto-applied when `background_tasks_enabled` is
+   * `true`. When `background_tasks_enabled` is `false`, the SDK does not
+   * touch the Spark private mode on startup; call `update_user_settings`
+   * with `spark_private_mode_enabled` set as needed on a one-time setup
+   * pass.
    */
   privateEnabledDefault: boolean;
   /**
@@ -2137,7 +2210,16 @@ export type Config = {
    * Fewer, bigger leaves allow for more funds to be exited unilaterally.
    * More leaves allow payments to be made without needing a swap, reducing payment latency.
    */
-  optimizationConfig: OptimizationConfig;
+  leafOptimizationConfig: LeafOptimizationConfig;
+  /**
+   * Configuration for token-output optimization.
+   *
+   * Token-output optimization controls automatic consolidation of a token's
+   * available outputs. Keeping the output set small reduces transaction size,
+   * while keeping enough distinct outputs preserves concurrency for parallel
+   * sends.
+   */
+  tokenOptimizationConfig: TokenOptimizationConfig;
   /**
    * Configuration for automatic conversion of Bitcoin to stable tokens.
    *
@@ -2159,6 +2241,33 @@ export type Config = {
    * deployments (e.g. dev/staging environments).
    */
   sparkConfig: SparkConfig | undefined;
+  /**
+   * Master switch for per-instance background services.
+   *
+   * When `true` (default), the SDK runs its standard background work:
+   * periodic sync, lightning-address recovery, private-mode initialization,
+   * the leaf and token-output optimizers, the Spark server-event
+   * subscription, and the real-time sync client (when
+   * `real_time_sync_server_url` is set).
+   *
+   * When `false`, **no background service is started**, regardless of any
+   * other setting on this config. This is intended for multi-tenant server
+   * deployments where the host application orchestrates sync and claims
+   * explicitly and receives events via webhooks. Use
+   * `default_server_config` to get this preset.
+   *
+   * Explicit operations (`sync_wallet`, `claim_deposit`,
+   * `list_unclaimed_deposits`, `refund_deposit`,
+   * `refund_pending_conversions`, leaf/token optimization, etc.) work
+   * regardless of this flag.
+   *
+   * When `false`, the SDK rejects builds where fields whose backing
+   * service is gated off are still in their active shape:
+   * `stable_balance_config` must be `None`, `real_time_sync_server_url`
+   * must be `None`, and `optimization_config.auto_enabled` must be `false`.
+   * `default_server_config` already sets these compatible values.
+   */
+  backgroundTasksEnabled: boolean;
 };
 
 /**
@@ -2205,11 +2314,15 @@ const FfiConverterTypeConfig = (() => {
         useDefaultExternalInputParsers: FfiConverterBool.read(from),
         realTimeSyncServerUrl: FfiConverterOptionalString.read(from),
         privateEnabledDefault: FfiConverterBool.read(from),
-        optimizationConfig: FfiConverterTypeOptimizationConfig.read(from),
+        leafOptimizationConfig:
+          FfiConverterTypeLeafOptimizationConfig.read(from),
+        tokenOptimizationConfig:
+          FfiConverterTypeTokenOptimizationConfig.read(from),
         stableBalanceConfig:
           FfiConverterOptionalTypeStableBalanceConfig.read(from),
         maxConcurrentClaims: FfiConverterUInt32.read(from),
         sparkConfig: FfiConverterOptionalTypeSparkConfig.read(from),
+        backgroundTasksEnabled: FfiConverterBool.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
@@ -2226,13 +2339,21 @@ const FfiConverterTypeConfig = (() => {
       FfiConverterBool.write(value.useDefaultExternalInputParsers, into);
       FfiConverterOptionalString.write(value.realTimeSyncServerUrl, into);
       FfiConverterBool.write(value.privateEnabledDefault, into);
-      FfiConverterTypeOptimizationConfig.write(value.optimizationConfig, into);
+      FfiConverterTypeLeafOptimizationConfig.write(
+        value.leafOptimizationConfig,
+        into
+      );
+      FfiConverterTypeTokenOptimizationConfig.write(
+        value.tokenOptimizationConfig,
+        into
+      );
       FfiConverterOptionalTypeStableBalanceConfig.write(
         value.stableBalanceConfig,
         into
       );
       FfiConverterUInt32.write(value.maxConcurrentClaims, into);
       FfiConverterOptionalTypeSparkConfig.write(value.sparkConfig, into);
+      FfiConverterBool.write(value.backgroundTasksEnabled, into);
     }
     allocationSize(value: TypeName): number {
       return (
@@ -2250,14 +2371,18 @@ const FfiConverterTypeConfig = (() => {
         FfiConverterBool.allocationSize(value.useDefaultExternalInputParsers) +
         FfiConverterOptionalString.allocationSize(value.realTimeSyncServerUrl) +
         FfiConverterBool.allocationSize(value.privateEnabledDefault) +
-        FfiConverterTypeOptimizationConfig.allocationSize(
-          value.optimizationConfig
+        FfiConverterTypeLeafOptimizationConfig.allocationSize(
+          value.leafOptimizationConfig
+        ) +
+        FfiConverterTypeTokenOptimizationConfig.allocationSize(
+          value.tokenOptimizationConfig
         ) +
         FfiConverterOptionalTypeStableBalanceConfig.allocationSize(
           value.stableBalanceConfig
         ) +
         FfiConverterUInt32.allocationSize(value.maxConcurrentClaims) +
-        FfiConverterOptionalTypeSparkConfig.allocationSize(value.sparkConfig)
+        FfiConverterOptionalTypeSparkConfig.allocationSize(value.sparkConfig) +
+        FfiConverterBool.allocationSize(value.backgroundTasksEnabled)
       );
     }
   }
@@ -4575,6 +4700,14 @@ const FfiConverterTypeFreezeIssuerTokenResponse = (() => {
  * Request to get the balance of the wallet
  */
 export type GetInfoRequest = {
+  /**
+   * When `Some(true)`, and `background_tasks_enabled` is `true`, the call
+   * waits for the initial Full sync to complete before returning.
+   *
+   * When `background_tasks_enabled` is `false`, setting this to `Some(true)`
+   * is rejected with an invalid-input error. There is no background sync to
+   * wait on; call `sync_wallet` explicitly first if you need fresh state.
+   */
   ensureSynced: boolean | undefined;
 };
 
@@ -5295,6 +5428,90 @@ const FfiConverterTypeKeySetConfig = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Configuration for leaf optimization.
+ */
+export type LeafOptimizationConfig = {
+  /**
+   * Whether automatic leaf optimization is enabled.
+   *
+   * If set to true, the SDK will automatically optimize the leaf set when it changes.
+   * Otherwise, the manual optimization API must be used to optimize the leaf set.
+   *
+   * Default value is true.
+   */
+  autoEnabled: boolean;
+  /**
+   * The desired multiplicity for the leaf set.
+   *
+   * Setting this to 0 will optimize for maximizing unilateral exit.
+   * Higher values will optimize for minimizing transfer swaps, with higher values
+   * being more aggressive and allowing better TPS rates.
+   *
+   * For end-user wallets, values of 1-5 are recommended. Values above 5 are
+   * intended for high-throughput server environments and are not recommended
+   * for end-user wallets due to significantly higher unilateral exit costs.
+   *
+   * Default value is 1.
+   */
+  multiplicity: /*u8*/ number;
+};
+
+/**
+ * Generated factory for {@link LeafOptimizationConfig} record objects.
+ */
+export const LeafOptimizationConfig = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      LeafOptimizationConfig,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LeafOptimizationConfig}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link LeafOptimizationConfig}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<LeafOptimizationConfig>,
+  });
+})();
+
+const FfiConverterTypeLeafOptimizationConfig = (() => {
+  type TypeName = LeafOptimizationConfig;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        autoEnabled: FfiConverterBool.read(from),
+        multiplicity: FfiConverterUInt8.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterBool.write(value.autoEnabled, into);
+      FfiConverterUInt8.write(value.multiplicity, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterBool.allocationSize(value.autoEnabled) +
+        FfiConverterUInt8.allocationSize(value.multiplicity)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type LightningAddressDetails = {
   address: string;
   payRequest: LnurlPayRequestDetails;
@@ -7186,85 +7403,6 @@ const FfiConverterTypeNostrRelayConfig = (() => {
   return new FFIConverter();
 })();
 
-export type OptimizationConfig = {
-  /**
-   * Whether automatic leaf optimization is enabled.
-   *
-   * If set to true, the SDK will automatically optimize the leaf set when it changes.
-   * Otherwise, the manual optimization API must be used to optimize the leaf set.
-   *
-   * Default value is true.
-   */
-  autoEnabled: boolean;
-  /**
-   * The desired multiplicity for the leaf set.
-   *
-   * Setting this to 0 will optimize for maximizing unilateral exit.
-   * Higher values will optimize for minimizing transfer swaps, with higher values
-   * being more aggressive and allowing better TPS rates.
-   *
-   * For end-user wallets, values of 1-5 are recommended. Values above 5 are
-   * intended for high-throughput server environments and are not recommended
-   * for end-user wallets due to significantly higher unilateral exit costs.
-   *
-   * Default value is 1.
-   */
-  multiplicity: /*u8*/ number;
-};
-
-/**
- * Generated factory for {@link OptimizationConfig} record objects.
- */
-export const OptimizationConfig = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord<OptimizationConfig, ReturnType<typeof defaults>>(
-      defaults
-    );
-  })();
-  return Object.freeze({
-    /**
-     * Create a frozen instance of {@link OptimizationConfig}, with defaults specified
-     * in Rust, in the {@link breez_sdk_spark} crate.
-     */
-    create,
-
-    /**
-     * Create a frozen instance of {@link OptimizationConfig}, with defaults specified
-     * in Rust, in the {@link breez_sdk_spark} crate.
-     */
-    new: create,
-
-    /**
-     * Defaults specified in the {@link breez_sdk_spark} crate.
-     */
-    defaults: () => Object.freeze(defaults()) as Partial<OptimizationConfig>,
-  });
-})();
-
-const FfiConverterTypeOptimizationConfig = (() => {
-  type TypeName = OptimizationConfig;
-  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-    read(from: RustBuffer): TypeName {
-      return {
-        autoEnabled: FfiConverterBool.read(from),
-        multiplicity: FfiConverterUInt8.read(from),
-      };
-    }
-    write(value: TypeName, into: RustBuffer): void {
-      FfiConverterBool.write(value.autoEnabled, into);
-      FfiConverterUInt8.write(value.multiplicity, into);
-    }
-    allocationSize(value: TypeName): number {
-      return (
-        FfiConverterBool.allocationSize(value.autoEnabled) +
-        FfiConverterUInt8.allocationSize(value.multiplicity)
-      );
-    }
-  }
-  return new FFIConverter();
-})();
-
 export type OptimizationProgress = {
   isRunning: boolean;
   currentRound: /*u32*/ number;
@@ -9121,6 +9259,91 @@ const FfiConverterTypeSchnorrSignatureBytes = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Settings for [`new_shared_sdk_context`]. All fields are optional; the defaults
+ * match the single-SDK happy path.
+ */
+export type SdkContextConfig = {
+  /**
+   * Network the shared resources target. Defaults to [`Network::Mainnet`].
+   * Used to gate the partner JWT header provider — only constructed on
+   * Mainnet, since Regtest has no JWT-issuing Breez endpoint.
+   */
+  network: Network;
+  /**
+   * Breez API key. When set together with `network == Mainnet`, the
+   * context constructs a shared partner JWT header provider that all
+   * SDKs built from this context will attach to their SO requests.
+   */
+  apiKey: string | undefined;
+  /**
+   * Number of gRPC connections per Spark operator. `None` (or `Some(1)`)
+   * keeps a single connection per operator (the right choice for most
+   * deployments); `Some(n)` opens `n` channels per operator and balances
+   * requests across them.
+   */
+  connectionsPerOperator: /*u32*/ number | undefined;
+};
+
+/**
+ * Generated factory for {@link SdkContextConfig} record objects.
+ */
+export const SdkContextConfig = (() => {
+  const defaults = () => ({
+    apiKey: undefined,
+    connectionsPerOperator: undefined,
+  });
+  const create = (() => {
+    return uniffiCreateRecord<SdkContextConfig, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link SdkContextConfig}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link SdkContextConfig}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<SdkContextConfig>,
+  });
+})();
+
+const FfiConverterTypeSdkContextConfig = (() => {
+  type TypeName = SdkContextConfig;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        network: FfiConverterTypeNetwork.read(from),
+        apiKey: FfiConverterOptionalString.read(from),
+        connectionsPerOperator: FfiConverterOptionalUInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeNetwork.write(value.network, into);
+      FfiConverterOptionalString.write(value.apiKey, into);
+      FfiConverterOptionalUInt32.write(value.connectionsPerOperator, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeNetwork.allocationSize(value.network) +
+        FfiConverterOptionalString.allocationSize(value.apiKey) +
+        FfiConverterOptionalUInt32.allocationSize(value.connectionsPerOperator)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * FFI-safe representation of a private key (32 bytes)
  */
@@ -11065,6 +11288,106 @@ const FfiConverterTypeTokenMetadata = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Configuration for token-output optimization.
+ */
+export type TokenOptimizationConfig = {
+  /**
+   * Whether automatic token-output consolidation is enabled.
+   *
+   * If set to true, the SDK will periodically consolidate a token's outputs
+   * once their count exceeds [`Self::min_outputs_threshold`]. Otherwise, no
+   * automatic consolidation is performed.
+   *
+   * Default value is true.
+   */
+  autoEnabled: boolean;
+  /**
+   * Number of token outputs to produce when token-output auto-consolidation
+   * fires.
+   *
+   * Instead of collapsing a token's outputs into a single output (which
+   * serializes subsequent payments), the SDK splits the consolidated balance
+   * across this many outputs of roughly equal value. Higher values preserve
+   * concurrency for parallel sends at the cost of a slightly larger output
+   * set.
+   *
+   * Must be >= 1 and strictly less than [`Self::min_outputs_threshold`].
+   *
+   * Default value is 5.
+   */
+  targetOutputCount: /*u32*/ number;
+  /**
+   * Output count that triggers per-token auto-consolidation.
+   *
+   * Auto-consolidation triggers for a token when its available output count
+   * strictly exceeds this threshold.
+   *
+   * Must be greater than 1.
+   *
+   * Default value is 50.
+   */
+  minOutputsThreshold: /*u32*/ number;
+};
+
+/**
+ * Generated factory for {@link TokenOptimizationConfig} record objects.
+ */
+export const TokenOptimizationConfig = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      TokenOptimizationConfig,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link TokenOptimizationConfig}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link TokenOptimizationConfig}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<TokenOptimizationConfig>,
+  });
+})();
+
+const FfiConverterTypeTokenOptimizationConfig = (() => {
+  type TypeName = TokenOptimizationConfig;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        autoEnabled: FfiConverterBool.read(from),
+        targetOutputCount: FfiConverterUInt32.read(from),
+        minOutputsThreshold: FfiConverterUInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterBool.write(value.autoEnabled, into);
+      FfiConverterUInt32.write(value.targetOutputCount, into);
+      FfiConverterUInt32.write(value.minOutputsThreshold, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterBool.allocationSize(value.autoEnabled) +
+        FfiConverterUInt32.allocationSize(value.targetOutputCount) +
+        FfiConverterUInt32.allocationSize(value.minOutputsThreshold)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type TxStatus = {
   confirmed: boolean;
   blockHeight: /*u32*/ number | undefined;
@@ -23708,6 +24031,20 @@ export interface BreezSdkInterface {
     request: RefundDepositRequest,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<RefundDepositResponse>;
+  /**
+   * Runs one pass of the pending-conversion refunder.
+   *
+   * Iterates over payments whose conversions failed and have a refund
+   * pending, then attempts to refund each one. This is the same logic the
+   * SDK runs internally on a periodic schedule when
+   * `background_tasks_enabled` is `true`. When background tasks are
+   * disabled the periodic refunder does not run, and this method is the
+   * explicit entry point for driving the pass; when background tasks are
+   * enabled, it can be called to force an immediate refund pass.
+   */
+  refundPendingConversions(asyncOpts_?: {
+    signal: AbortSignal;
+  }): /*throws*/ Promise<void>;
   registerLightningAddress(
     request: RegisterLightningAddressRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -25242,6 +25579,52 @@ export class BreezSdk
     }
   }
 
+  /**
+   * Runs one pass of the pending-conversion refunder.
+   *
+   * Iterates over payments whose conversions failed and have a refund
+   * pending, then attempts to refund each one. This is the same logic the
+   * SDK runs internally on a periodic schedule when
+   * `background_tasks_enabled` is `true`. When background tasks are
+   * disabled the periodic refunder does not run, and this method is the
+   * explicit entry point for driving the pass; when background tasks are
+   * enabled, it can be called to force an immediate refund pass.
+   */
+  public async refundPendingConversions(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_breezsdk_refund_pending_conversions(
+            uniffiTypeBreezSdkObjectFactory.clonePointer(this)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_void,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_void,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_void,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_void,
+        /*liftFunc:*/ (_v) => {},
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSdkError.lift.bind(
+          FfiConverterTypeSdkError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   public async registerLightningAddress(
     request: RegisterLightningAddressRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -25769,136 +26152,6 @@ const FfiConverterTypeBreezSdk = new FfiConverterObject(
   uniffiTypeBreezSdkObjectFactory
 );
 
-/**
- * A shareable manager for gRPC connections to the Spark operators.
- *
- * Construct one via [`new_connection_manager`] and pass the same `Arc` to
- * multiple [`SdkBuilder`](crate::SdkBuilder)s via
- * [`SdkBuilder::with_connection_manager`](crate::SdkBuilder::with_connection_manager).
- * Connections close when the last `Arc<ConnectionManager>` is dropped;
- * [`BreezSdk::disconnect`](crate::BreezSdk::disconnect) does not affect them.
- *
- * All SDK instances sharing a `ConnectionManager` must be configured for the
- * same network and operator pool. The TLS settings and user agent of the
- * first SDK to connect to a given operator are reused for everyone afterwards.
- */
-export interface ConnectionManagerInterface {}
-
-/**
- * A shareable manager for gRPC connections to the Spark operators.
- *
- * Construct one via [`new_connection_manager`] and pass the same `Arc` to
- * multiple [`SdkBuilder`](crate::SdkBuilder)s via
- * [`SdkBuilder::with_connection_manager`](crate::SdkBuilder::with_connection_manager).
- * Connections close when the last `Arc<ConnectionManager>` is dropped;
- * [`BreezSdk::disconnect`](crate::BreezSdk::disconnect) does not affect them.
- *
- * All SDK instances sharing a `ConnectionManager` must be configured for the
- * same network and operator pool. The TLS settings and user agent of the
- * first SDK to connect to a given operator are reused for everyone afterwards.
- */
-export class ConnectionManager
-  extends UniffiAbstractObject
-  implements ConnectionManagerInterface
-{
-  readonly [uniffiTypeNameSymbol] = 'ConnectionManager';
-  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
-  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
-  // No primary constructor declared for this class.
-  private constructor(pointer: UnsafeMutableRawPointer) {
-    super();
-    this[pointerLiteralSymbol] = pointer;
-    this[destructorGuardSymbol] =
-      uniffiTypeConnectionManagerObjectFactory.bless(pointer);
-  }
-
-  /**
-   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
-   */
-  uniffiDestroy(): void {
-    const ptr = (this as any)[destructorGuardSymbol];
-    if (ptr !== undefined) {
-      const pointer = uniffiTypeConnectionManagerObjectFactory.pointer(this);
-      uniffiTypeConnectionManagerObjectFactory.freePointer(pointer);
-      uniffiTypeConnectionManagerObjectFactory.unbless(ptr);
-      delete (this as any)[destructorGuardSymbol];
-    }
-  }
-
-  static instanceOf(obj: any): obj is ConnectionManager {
-    return uniffiTypeConnectionManagerObjectFactory.isConcreteType(obj);
-  }
-}
-
-const uniffiTypeConnectionManagerObjectFactory: UniffiObjectFactory<ConnectionManagerInterface> =
-  (() => {
-    return {
-      create(pointer: UnsafeMutableRawPointer): ConnectionManagerInterface {
-        const instance = Object.create(ConnectionManager.prototype);
-        instance[pointerLiteralSymbol] = pointer;
-        instance[destructorGuardSymbol] = this.bless(pointer);
-        instance[uniffiTypeNameSymbol] = 'ConnectionManager';
-        return instance;
-      },
-
-      bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
-        return uniffiCaller.rustCall(
-          /*caller:*/ (status) =>
-            nativeModule().ubrn_uniffi_internal_fn_method_connectionmanager_ffi__bless_pointer(
-              p,
-              status
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
-
-      unbless(ptr: UniffiRustArcPtr) {
-        ptr.markDestroyed();
-      },
-
-      pointer(obj: ConnectionManagerInterface): UnsafeMutableRawPointer {
-        if ((obj as any)[destructorGuardSymbol] === undefined) {
-          throw new UniffiInternalError.UnexpectedNullPointer();
-        }
-        return (obj as any)[pointerLiteralSymbol];
-      },
-
-      clonePointer(obj: ConnectionManagerInterface): UnsafeMutableRawPointer {
-        const pointer = this.pointer(obj);
-        return uniffiCaller.rustCall(
-          /*caller:*/ (callStatus) =>
-            nativeModule().ubrn_uniffi_breez_sdk_spark_fn_clone_connectionmanager(
-              pointer,
-              callStatus
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
-
-      freePointer(pointer: UnsafeMutableRawPointer): void {
-        uniffiCaller.rustCall(
-          /*caller:*/ (callStatus) =>
-            nativeModule().ubrn_uniffi_breez_sdk_spark_fn_free_connectionmanager(
-              pointer,
-              callStatus
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
-
-      isConcreteType(obj: any): obj is ConnectionManagerInterface {
-        return (
-          obj[destructorGuardSymbol] &&
-          obj[uniffiTypeNameSymbol] === 'ConnectionManager'
-        );
-      },
-    };
-  })();
-// FfiConverter for ConnectionManagerInterface
-const FfiConverterTypeConnectionManager = new FfiConverterObject(
-  uniffiTypeConnectionManagerObjectFactory
-);
-
 /**
  * External signer trait that can be implemented by users and passed to the SDK.
  *
@@ -30085,15 +30338,6 @@ export interface SdkBuilderInterface {
     chainService: BitcoinChainService,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void>;
-  /**
-   * Sets a shared connection manager to be reused across SDK instances.
-   * Arguments:
-   * - `connection_manager`: The shared connection manager.
-   */
-  withConnectionManager(
-    connectionManager: ConnectionManagerInterface,
-    asyncOpts_?: { signal: AbortSignal }
-  ): Promise<void>;
   /**
    * Sets the root storage directory to initialize the default storage with.
    * This initializes both storage and real-time sync storage with the
@@ -30150,23 +30394,15 @@ export interface SdkBuilderInterface {
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void>;
   /**
-   * Sets a custom session manager used to persist authentication sessions.
+   * Threads a shared [`SdkContext`](crate::SdkContext) into the builder.
    *
-   * 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.
+   * Construct the context once via
+   * [`new_shared_sdk_context`](crate::new_shared_sdk_context) and pass the
+   * same `Arc` to every `SdkBuilder` whose SDKs should share its resources
+   * (operator gRPC channels, SSP HTTP client, database pool).
    */
-  withSessionManager(
-    sessionManager: SessionManager,
-    asyncOpts_?: { signal: AbortSignal }
-  ): Promise<void>;
-  /**
-   * Sets a shared SSP connection manager to be reused across SDK instances.
-   * Arguments:
-   * - `manager`: The shared SSP connection manager.
-   */
-  withSspConnectionManager(
-    manager: SspConnectionManagerInterface,
+  withSharedContext(
+    context: SdkContextInterface,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void>;
   /**
@@ -30292,45 +30528,6 @@ export class SdkBuilder
     }
   }
 
-  /**
-   * Sets a shared connection manager to be reused across SDK instances.
-   * Arguments:
-   * - `connection_manager`: The shared connection manager.
-   */
-  public async withConnectionManager(
-    connectionManager: ConnectionManagerInterface,
-    asyncOpts_?: { signal: AbortSignal }
-  ): Promise<void> {
-    const __stack = uniffiIsDebug ? new Error().stack : undefined;
-    try {
-      return await uniffiRustCallAsync(
-        /*rustCaller:*/ uniffiCaller,
-        /*rustFutureFunc:*/ () => {
-          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_connection_manager(
-            uniffiTypeSdkBuilderObjectFactory.clonePointer(this),
-            FfiConverterTypeConnectionManager.lower(connectionManager)
-          );
-        },
-        /*pollFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_poll_void,
-        /*cancelFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_void,
-        /*completeFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_complete_void,
-        /*freeFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_free_void,
-        /*liftFunc:*/ (_v) => {},
-        /*liftString:*/ FfiConverterString.lift,
-        /*asyncOpts:*/ asyncOpts_
-      );
-    } catch (__error: any) {
-      if (uniffiIsDebug && __error instanceof Error) {
-        __error.stack = __stack;
-      }
-      throw __error;
-    }
-  }
-
   /**
    * Sets the root storage directory to initialize the default storage with.
    * This initializes both storage and real-time sync storage with the
@@ -30411,47 +30608,13 @@ export class SdkBuilder
     }
   }
 
-  /**
-   * Sets the key set type to be used by the SDK.
-   * Arguments:
-   * - `config`: Key set configuration containing the key set type, address index flag, and optional account number.
-   */
-  public async withKeySet(
-    config: KeySetConfig,
-    asyncOpts_?: { signal: AbortSignal }
-  ): Promise<void> {
-    const __stack = uniffiIsDebug ? new Error().stack : undefined;
-    try {
-      return await uniffiRustCallAsync(
-        /*rustCaller:*/ uniffiCaller,
-        /*rustFutureFunc:*/ () => {
-          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_key_set(
-            uniffiTypeSdkBuilderObjectFactory.clonePointer(this),
-            FfiConverterTypeKeySetConfig.lower(config)
-          );
-        },
-        /*pollFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_poll_void,
-        /*cancelFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_void,
-        /*completeFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_complete_void,
-        /*freeFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_free_void,
-        /*liftFunc:*/ (_v) => {},
-        /*liftString:*/ FfiConverterString.lift,
-        /*asyncOpts:*/ asyncOpts_
-      );
-    } catch (__error: any) {
-      if (uniffiIsDebug && __error instanceof Error) {
-        __error.stack = __stack;
-      }
-      throw __error;
-    }
-  }
-
-  public async withLnurlClient(
-    lnurlClient: RestClient,
+  /**
+   * Sets the key set type to be used by the SDK.
+   * Arguments:
+   * - `config`: Key set configuration containing the key set type, address index flag, and optional account number.
+   */
+  public async withKeySet(
+    config: KeySetConfig,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void> {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -30459,9 +30622,9 @@ export class SdkBuilder
       return await uniffiRustCallAsync(
         /*rustCaller:*/ uniffiCaller,
         /*rustFutureFunc:*/ () => {
-          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_lnurl_client(
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_key_set(
             uniffiTypeSdkBuilderObjectFactory.clonePointer(this),
-            FfiConverterTypeRestClient.lower(lnurlClient)
+            FfiConverterTypeKeySetConfig.lower(config)
           );
         },
         /*pollFunc:*/ nativeModule()
@@ -30484,13 +30647,8 @@ export class SdkBuilder
     }
   }
 
-  /**
-   * Sets the payment observer to be used by the SDK.
-   * Arguments:
-   * - `payment_observer`: The payment observer to be used.
-   */
-  public async withPaymentObserver(
-    paymentObserver: PaymentObserver,
+  public async withLnurlClient(
+    lnurlClient: RestClient,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void> {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -30498,9 +30656,9 @@ export class SdkBuilder
       return await uniffiRustCallAsync(
         /*rustCaller:*/ uniffiCaller,
         /*rustFutureFunc:*/ () => {
-          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_payment_observer(
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_lnurl_client(
             uniffiTypeSdkBuilderObjectFactory.clonePointer(this),
-            FfiConverterTypePaymentObserver.lower(paymentObserver)
+            FfiConverterTypeRestClient.lower(lnurlClient)
           );
         },
         /*pollFunc:*/ nativeModule()
@@ -30524,16 +30682,12 @@ export class SdkBuilder
   }
 
   /**
-   * Sets the REST chain service to be used by the SDK.
+   * Sets the payment observer to be used by the SDK.
    * Arguments:
-   * - `url`: The base URL of the REST API.
-   * - `api_type`: The API type to be used.
-   * - `credentials`: Optional credentials for basic authentication.
+   * - `payment_observer`: The payment observer to be used.
    */
-  public async withRestChainService(
-    url: string,
-    apiType: ChainApiType,
-    credentials: Credentials | undefined,
+  public async withPaymentObserver(
+    paymentObserver: PaymentObserver,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void> {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -30541,11 +30695,9 @@ export class SdkBuilder
       return await uniffiRustCallAsync(
         /*rustCaller:*/ uniffiCaller,
         /*rustFutureFunc:*/ () => {
-          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_rest_chain_service(
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_payment_observer(
             uniffiTypeSdkBuilderObjectFactory.clonePointer(this),
-            FfiConverterString.lower(url),
-            FfiConverterTypeChainApiType.lower(apiType),
-            FfiConverterOptionalTypeCredentials.lower(credentials)
+            FfiConverterTypePaymentObserver.lower(paymentObserver)
           );
         },
         /*pollFunc:*/ nativeModule()
@@ -30569,14 +30721,16 @@ export class SdkBuilder
   }
 
   /**
-   * 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.
+   * Sets the REST chain service to be used by the SDK.
+   * Arguments:
+   * - `url`: The base URL of the REST API.
+   * - `api_type`: The API type to be used.
+   * - `credentials`: Optional credentials for basic authentication.
    */
-  public async withSessionManager(
-    sessionManager: SessionManager,
+  public async withRestChainService(
+    url: string,
+    apiType: ChainApiType,
+    credentials: Credentials | undefined,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void> {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -30584,9 +30738,11 @@ export class SdkBuilder
       return await uniffiRustCallAsync(
         /*rustCaller:*/ uniffiCaller,
         /*rustFutureFunc:*/ () => {
-          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_session_manager(
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_rest_chain_service(
             uniffiTypeSdkBuilderObjectFactory.clonePointer(this),
-            FfiConverterTypeSessionManager.lower(sessionManager)
+            FfiConverterString.lower(url),
+            FfiConverterTypeChainApiType.lower(apiType),
+            FfiConverterOptionalTypeCredentials.lower(credentials)
           );
         },
         /*pollFunc:*/ nativeModule()
@@ -30610,12 +30766,15 @@ export class SdkBuilder
   }
 
   /**
-   * Sets a shared SSP connection manager to be reused across SDK instances.
-   * Arguments:
-   * - `manager`: The shared SSP connection manager.
+   * Threads a shared [`SdkContext`](crate::SdkContext) into the builder.
+   *
+   * Construct the context once via
+   * [`new_shared_sdk_context`](crate::new_shared_sdk_context) and pass the
+   * same `Arc` to every `SdkBuilder` whose SDKs should share its resources
+   * (operator gRPC channels, SSP HTTP client, database pool).
    */
-  public async withSspConnectionManager(
-    manager: SspConnectionManagerInterface,
+  public async withSharedContext(
+    context: SdkContextInterface,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void> {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -30623,9 +30782,9 @@ export class SdkBuilder
       return await uniffiRustCallAsync(
         /*rustCaller:*/ uniffiCaller,
         /*rustFutureFunc:*/ () => {
-          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_ssp_connection_manager(
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_with_shared_context(
             uniffiTypeSdkBuilderObjectFactory.clonePointer(this),
-            FfiConverterTypeSspConnectionManager.lower(manager)
+            FfiConverterTypeSdkContext.lower(context)
           );
         },
         /*pollFunc:*/ nativeModule()
@@ -30774,6 +30933,140 @@ const FfiConverterTypeSdkBuilder = new FfiConverterObject(
   uniffiTypeSdkBuilderObjectFactory
 );
 
+/**
+ * Process-shared resources that can back many `BreezSdk` instances.
+ *
+ * Construct one with [`new_shared_sdk_context`] and pass the same `Arc` to every
+ * [`SdkBuilder`](crate::SdkBuilder) whose SDKs should share those resources
+ * (a single HTTP client across SSP / chain / LNURL / JWT / etc., a gRPC
+ * channel pool to the Spark operators, the Breez backend gRPC client, a
+ * database connection pool, …). Useful for multi-tenant servers that load
+ * many wallets in one process.
+ *
+ * The struct is intentionally opaque — all fields are crate-private. There
+ * is no way to inject pre-built sub-components: the factory builds them
+ * from settings so callers don't need to know about session managers,
+ * connection-manager wiring, or pool plumbing.
+ */
+export interface SdkContextInterface {}
+
+/**
+ * Process-shared resources that can back many `BreezSdk` instances.
+ *
+ * Construct one with [`new_shared_sdk_context`] and pass the same `Arc` to every
+ * [`SdkBuilder`](crate::SdkBuilder) whose SDKs should share those resources
+ * (a single HTTP client across SSP / chain / LNURL / JWT / etc., a gRPC
+ * channel pool to the Spark operators, the Breez backend gRPC client, a
+ * database connection pool, …). Useful for multi-tenant servers that load
+ * many wallets in one process.
+ *
+ * The struct is intentionally opaque — all fields are crate-private. There
+ * is no way to inject pre-built sub-components: the factory builds them
+ * from settings so callers don't need to know about session managers,
+ * connection-manager wiring, or pool plumbing.
+ */
+export class SdkContext
+  extends UniffiAbstractObject
+  implements SdkContextInterface
+{
+  readonly [uniffiTypeNameSymbol] = 'SdkContext';
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+  // No primary constructor declared for this class.
+  private constructor(pointer: UnsafeMutableRawPointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] =
+      uniffiTypeSdkContextObjectFactory.bless(pointer);
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeSdkContextObjectFactory.pointer(this);
+      uniffiTypeSdkContextObjectFactory.freePointer(pointer);
+      uniffiTypeSdkContextObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is SdkContext {
+    return uniffiTypeSdkContextObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeSdkContextObjectFactory: UniffiObjectFactory<SdkContextInterface> =
+  (() => {
+    return {
+      create(pointer: UnsafeMutableRawPointer): SdkContextInterface {
+        const instance = Object.create(SdkContext.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = 'SdkContext';
+        return instance;
+      },
+
+      bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+        return uniffiCaller.rustCall(
+          /*caller:*/ (status) =>
+            nativeModule().ubrn_uniffi_internal_fn_method_sdkcontext_ffi__bless_pointer(
+              p,
+              status
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      unbless(ptr: UniffiRustArcPtr) {
+        ptr.markDestroyed();
+      },
+
+      pointer(obj: SdkContextInterface): UnsafeMutableRawPointer {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+          throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+      },
+
+      clonePointer(obj: SdkContextInterface): UnsafeMutableRawPointer {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_breez_sdk_spark_fn_clone_sdkcontext(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      freePointer(pointer: UnsafeMutableRawPointer): void {
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_breez_sdk_spark_fn_free_sdkcontext(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      isConcreteType(obj: any): obj is SdkContextInterface {
+        return (
+          obj[destructorGuardSymbol] &&
+          obj[uniffiTypeNameSymbol] === 'SdkContext'
+        );
+      },
+    };
+  })();
+// FfiConverter for SdkContextInterface
+const FfiConverterTypeSdkContext = new FfiConverterObject(
+  uniffiTypeSdkContextObjectFactory
+);
+
 /**
  * Persistent storage for authentication sessions, keyed by the service's
  * identity public key. Implementations should be thread-safe and may be
@@ -31092,146 +31385,6 @@ const uniffiCallbackInterfaceSessionManager: {
   },
 };
 
-/**
- * A shared HTTP transport for SSP GraphQL traffic.
- *
- * All SDK instances that are built with the same `SspConnectionManager` send
- * SSP requests over the same pooled `reqwest::Client`. This means each
- * process opens at most one TCP+TLS+HTTP/2 connection to the SSP regardless
- * of how many wallets are loaded — useful for multi-tenant servers running
- * many SDK instances.
- *
- * # Caveats
- *
- * - The user-agent of the first SDK to construct this manager is reused for
- * all subsequent instances. This is rarely a problem since SDK instances
- * in one process typically share a build version.
- * - Connections close when the last `Arc<SspConnectionManager>` is dropped.
- * `BreezSdk::disconnect` does not close them.
- */
-export interface SspConnectionManagerInterface {}
-
-/**
- * A shared HTTP transport for SSP GraphQL traffic.
- *
- * All SDK instances that are built with the same `SspConnectionManager` send
- * SSP requests over the same pooled `reqwest::Client`. This means each
- * process opens at most one TCP+TLS+HTTP/2 connection to the SSP regardless
- * of how many wallets are loaded — useful for multi-tenant servers running
- * many SDK instances.
- *
- * # Caveats
- *
- * - The user-agent of the first SDK to construct this manager is reused for
- * all subsequent instances. This is rarely a problem since SDK instances
- * in one process typically share a build version.
- * - Connections close when the last `Arc<SspConnectionManager>` is dropped.
- * `BreezSdk::disconnect` does not close them.
- */
-export class SspConnectionManager
-  extends UniffiAbstractObject
-  implements SspConnectionManagerInterface
-{
-  readonly [uniffiTypeNameSymbol] = 'SspConnectionManager';
-  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
-  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
-  // No primary constructor declared for this class.
-  private constructor(pointer: UnsafeMutableRawPointer) {
-    super();
-    this[pointerLiteralSymbol] = pointer;
-    this[destructorGuardSymbol] =
-      uniffiTypeSspConnectionManagerObjectFactory.bless(pointer);
-  }
-
-  /**
-   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
-   */
-  uniffiDestroy(): void {
-    const ptr = (this as any)[destructorGuardSymbol];
-    if (ptr !== undefined) {
-      const pointer = uniffiTypeSspConnectionManagerObjectFactory.pointer(this);
-      uniffiTypeSspConnectionManagerObjectFactory.freePointer(pointer);
-      uniffiTypeSspConnectionManagerObjectFactory.unbless(ptr);
-      delete (this as any)[destructorGuardSymbol];
-    }
-  }
-
-  static instanceOf(obj: any): obj is SspConnectionManager {
-    return uniffiTypeSspConnectionManagerObjectFactory.isConcreteType(obj);
-  }
-}
-
-const uniffiTypeSspConnectionManagerObjectFactory: UniffiObjectFactory<SspConnectionManagerInterface> =
-  (() => {
-    return {
-      create(pointer: UnsafeMutableRawPointer): SspConnectionManagerInterface {
-        const instance = Object.create(SspConnectionManager.prototype);
-        instance[pointerLiteralSymbol] = pointer;
-        instance[destructorGuardSymbol] = this.bless(pointer);
-        instance[uniffiTypeNameSymbol] = 'SspConnectionManager';
-        return instance;
-      },
-
-      bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
-        return uniffiCaller.rustCall(
-          /*caller:*/ (status) =>
-            nativeModule().ubrn_uniffi_internal_fn_method_sspconnectionmanager_ffi__bless_pointer(
-              p,
-              status
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
-
-      unbless(ptr: UniffiRustArcPtr) {
-        ptr.markDestroyed();
-      },
-
-      pointer(obj: SspConnectionManagerInterface): UnsafeMutableRawPointer {
-        if ((obj as any)[destructorGuardSymbol] === undefined) {
-          throw new UniffiInternalError.UnexpectedNullPointer();
-        }
-        return (obj as any)[pointerLiteralSymbol];
-      },
-
-      clonePointer(
-        obj: SspConnectionManagerInterface
-      ): UnsafeMutableRawPointer {
-        const pointer = this.pointer(obj);
-        return uniffiCaller.rustCall(
-          /*caller:*/ (callStatus) =>
-            nativeModule().ubrn_uniffi_breez_sdk_spark_fn_clone_sspconnectionmanager(
-              pointer,
-              callStatus
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
-
-      freePointer(pointer: UnsafeMutableRawPointer): void {
-        uniffiCaller.rustCall(
-          /*caller:*/ (callStatus) =>
-            nativeModule().ubrn_uniffi_breez_sdk_spark_fn_free_sspconnectionmanager(
-              pointer,
-              callStatus
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
-
-      isConcreteType(obj: any): obj is SspConnectionManagerInterface {
-        return (
-          obj[destructorGuardSymbol] &&
-          obj[uniffiTypeNameSymbol] === 'SspConnectionManager'
-        );
-      },
-    };
-  })();
-// FfiConverter for SspConnectionManagerInterface
-const FfiConverterTypeSspConnectionManager = new FfiConverterObject(
-  uniffiTypeSspConnectionManagerObjectFactory
-);
-
 /**
  * Trait for persistent storage
  */
@@ -35071,6 +35224,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_func_default_external_signer'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_func_default_server_config() !==
+    33858
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_func_default_server_config'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_func_get_spark_status() !==
     62888
@@ -35087,28 +35248,20 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_func_init_logging'
     );
   }
-  if (
-    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_func_new_connection_manager() !==
-    25164
-  ) {
-    throw new UniffiInternalError.ApiChecksumMismatch(
-      'uniffi_breez_sdk_spark_checksum_func_new_connection_manager'
-    );
-  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_func_new_rest_chain_service() !==
-    62980
+    23177
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_func_new_rest_chain_service'
     );
   }
   if (
-    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_func_new_ssp_connection_manager() !==
-    15222
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_func_new_shared_sdk_context() !==
+    28438
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
-      'uniffi_breez_sdk_spark_checksum_func_new_ssp_connection_manager'
+      'uniffi_breez_sdk_spark_checksum_func_new_shared_sdk_context'
     );
   }
   if (
@@ -35423,6 +35576,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_refund_deposit'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_refund_pending_conversions() !==
+    24173
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_breezsdk_refund_pending_conversions'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_register_lightning_address() !==
     530
@@ -35775,14 +35936,6 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_chain_service'
     );
   }
-  if (
-    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_connection_manager() !==
-    51797
-  ) {
-    throw new UniffiInternalError.ApiChecksumMismatch(
-      'uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_connection_manager'
-    );
-  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_default_storage() !==
     14543
@@ -35832,19 +35985,11 @@ function uniffiEnsureInitialized() {
     );
   }
   if (
-    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_session_manager() !==
-    64189
-  ) {
-    throw new UniffiInternalError.ApiChecksumMismatch(
-      'uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_session_manager'
-    );
-  }
-  if (
-    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_ssp_connection_manager() !==
-    65505
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_shared_context() !==
+    64829
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
-      'uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_ssp_connection_manager'
+      'uniffi_breez_sdk_spark_checksum_method_sdkbuilder_with_shared_context'
     );
   }
   if (
@@ -36229,7 +36374,6 @@ export default Object.freeze({
     FfiConverterTypeConfig,
     FfiConverterTypeConnectRequest,
     FfiConverterTypeConnectWithSignerRequest,
-    FfiConverterTypeConnectionManager,
     FfiConverterTypeContact,
     FfiConverterTypeConversionDetails,
     FfiConverterTypeConversionEstimate,
@@ -36283,6 +36427,7 @@ export default Object.freeze({
     FfiConverterTypeInputType,
     FfiConverterTypeKeySetConfig,
     FfiConverterTypeKeySetType,
+    FfiConverterTypeLeafOptimizationConfig,
     FfiConverterTypeLightningAddressDetails,
     FfiConverterTypeLightningAddressInfo,
     FfiConverterTypeListContactsRequest,
@@ -36315,7 +36460,6 @@ export default Object.freeze({
     FfiConverterTypeNetwork,
     FfiConverterTypeNostrRelayConfig,
     FfiConverterTypeOnchainConfirmationSpeed,
-    FfiConverterTypeOptimizationConfig,
     FfiConverterTypeOptimizationEvent,
     FfiConverterTypeOptimizationProgress,
     FfiConverterTypeOutgoingChange,
@@ -36359,6 +36503,8 @@ export default Object.freeze({
     FfiConverterTypeRestResponse,
     FfiConverterTypeSchnorrSignatureBytes,
     FfiConverterTypeSdkBuilder,
+    FfiConverterTypeSdkContext,
+    FfiConverterTypeSdkContextConfig,
     FfiConverterTypeSdkError,
     FfiConverterTypeSdkEvent,
     FfiConverterTypeSecretBytes,
@@ -36389,7 +36535,6 @@ export default Object.freeze({
     FfiConverterTypeSparkSigningOperator,
     FfiConverterTypeSparkSspConfig,
     FfiConverterTypeSparkStatus,
-    FfiConverterTypeSspConnectionManager,
     FfiConverterTypeStableBalanceActiveLabel,
     FfiConverterTypeStableBalanceConfig,
     FfiConverterTypeStableBalanceToken,
@@ -36405,6 +36550,7 @@ export default Object.freeze({
     FfiConverterTypeTokenBalance,
     FfiConverterTypeTokenIssuer,
     FfiConverterTypeTokenMetadata,
+    FfiConverterTypeTokenOptimizationConfig,
     FfiConverterTypeTokenTransactionType,
     FfiConverterTypeTxStatus,
     FfiConverterTypeUnfreezeIssuerTokenRequest,