@breeztech/breez-sdk-spark-react-native 0.24.1 → 0.26.0

package/lib/typescript/module/src/generated/breez_sdk_spark.d.ts

@@ -92,9 +92,9 @@ export declare function defaultConfig(network: Network): Config;
  *
  * * `mnemonic` - BIP39 mnemonic phrase (12 or 24 words)
  * * `passphrase` - Optional passphrase for the mnemonic
- * * `network` - Network to use (Mainnet or Regtest)
+ * * `network` - Network to use (Mainnet, Signet, or Regtest)
  * * `account_number` - Account number in the derivation path. Unset uses the
- * network default: 0 on Regtest, 1 on all other networks.
+ * network default: 0 on Regtest and Signet, 1 on Mainnet.
  */
 export declare function defaultExternalSigners(mnemonic: string, passphrase: string | undefined, network: Network, accountNumber: /*u32*/ number | undefined): ExternalSigners;
 /**
@@ -939,6 +939,63 @@ export declare const CheckMessageResponse: Readonly<{
      */
     defaults: () => Partial<CheckMessageResponse>;
 }>;
+/**
+ * Request for `check_unilateral_exit`: the exit you kept from a previous
+ * `unilateral_exit`, as you last stored it.
+ */
+export type CheckUnilateralExitRequest = {
+    exit: UnilateralExitResponse;
+};
+/**
+ * Generated factory for {@link CheckUnilateralExitRequest} record objects.
+ */
+export declare const CheckUnilateralExitRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link CheckUnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<CheckUnilateralExitRequest> & Required<Omit<CheckUnilateralExitRequest, never>>) => CheckUnilateralExitRequest;
+    /**
+     * Create a frozen instance of {@link CheckUnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<CheckUnilateralExitRequest> & Required<Omit<CheckUnilateralExitRequest, never>>) => CheckUnilateralExitRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<CheckUnilateralExitRequest>;
+}>;
+/**
+ * Result of `check_unilateral_exit`: the same exit, read back against the
+ * chain.
+ */
+export type CheckUnilateralExitResponse = {
+    /**
+     * The exit with each transaction's status brought up to date. Store it in
+     * place of the copy you passed in.
+     */
+    exit: UnilateralExitResponse;
+    verdict: UnilateralExitVerdict;
+};
+/**
+ * Generated factory for {@link CheckUnilateralExitResponse} record objects.
+ */
+export declare const CheckUnilateralExitResponse: Readonly<{
+    /**
+     * Create a frozen instance of {@link CheckUnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<CheckUnilateralExitResponse> & Required<Omit<CheckUnilateralExitResponse, never>>) => CheckUnilateralExitResponse;
+    /**
+     * Create a frozen instance of {@link CheckUnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<CheckUnilateralExitResponse> & Required<Omit<CheckUnilateralExitResponse, never>>) => CheckUnilateralExitResponse;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<CheckUnilateralExitResponse>;
+}>;
 /**
  * What one way of claiming a deposit costs.
  */
@@ -991,9 +1048,20 @@ export type ClaimDepositRequest = {
     txid: string;
     vout: number;
     /**
-     * Caps what the claim may cost. A deposit that has not matured is claimed
-     * instantly when the provider's spread fits within this, so the same ceiling
-     * governs both. Falls back to the configured max deposit claim fee.
+     * Caps what the claim may cost, and is recorded on the deposit so later
+     * automatic attempts are held to it too.
+     *
+     * Raising it above the quoted spread is what lets a deposit be claimed ahead
+     * of maturity without further input. Lowering it below the spread keeps the
+     * deposit from being claimed early, and does not hold back its claim at
+     * maturity: that one runs under whichever is larger, this or the configured
+     * max deposit claim fee.
+     *
+     * Unset claims under the configured max deposit claim fee and clears any
+     * ceiling previously recorded on the deposit.
+     *
+     * The ceiling is recorded before the claim is attempted, so it stands even
+     * when the attempt is then declined for exceeding it.
      */
     maxFee: MaxFee | undefined;
 };
@@ -1018,14 +1086,11 @@ export declare const ClaimDepositRequest: Readonly<{
 }>;
 export type ClaimDepositResponse = {
     /**
-     * The settled claim payment, present when the deposit was claimed at maturity,
-     * which completes synchronously. Absent when it was claimed before maturity,
-     * whose transfer settles asynchronously: watch for the payment via events or
-     * `list_payments`. Which of the two happens follows from the deposit's maturity
-     * and the fee ceiling, not from anything the caller asks for, so treat the
-     * payment as optional on every claim.
+     * What the call did. Which outcome occurs follows from the deposit's maturity
+     * and the fee ceiling, not from anything the caller asks for, so handle all
+     * three on every claim.
      */
-    payment: Payment | undefined;
+    outcome: ClaimDepositOutcome;
 };
 /**
  * Generated factory for {@link ClaimDepositResponse} record objects.
@@ -1148,15 +1213,20 @@ export type Config = {
     preferSparkOverLightning: boolean;
     /**
      * Whether the data needed to exit a payment unilaterally, without the Spark
-     * operators, is collected as funds arrive. Collection runs in the background,
-     * and a sync waits for a collection pass before returning, so syncing is how
-     * to make that happen at a moment of your choosing. A leaf the operators
-     * cannot complete stays un-exitable until a later attempt succeeds.
+     * operators, is collected automatically as funds arrive. Collection runs in
+     * the background, after an operation rather than during it. A leaf the
+     * operators cannot complete stays un-exitable until a later attempt
+     * succeeds.
      *
-     * Leave this on unless bandwidth matters more than being able to recover funds
-     * when the operators are unreachable. With it off, chains are only collected
-     * when an exit is prepared, which needs the operators reachable at that
-     * moment: a leaf cannot be exited without them until one is collected.
+     * Turn it off when collecting behind every operation costs more than it is
+     * worth, on a busy wallet holding many leaves. `sync_wallet` collects
+     * regardless of this flag, and waits for the pass before returning, so an
+     * explicit sync on a cadence of your choosing is how the data is kept
+     * current with the automatic collection off.
+     *
+     * Only that automatic collection is governed, so this has no effect at all
+     * where none runs: with `background_tasks_enabled` off there is no
+     * background collector, and every sync is an explicit one.
      *
      * Default value is true.
      */
@@ -1297,6 +1367,37 @@ export declare const Config: Readonly<{
      */
     defaults: () => Partial<Config>;
 }>;
+/**
+ * A node of the exit tree that is already on-chain.
+ */
+export type ConfirmedExitNode = {
+    nodeId: string;
+    confirmedBy: ExitNodeConfirmation;
+    /**
+     * The block it is in, where that is known. Unset for a node put in a block
+     * by a descendant's confirmation rather than read directly.
+     */
+    blockHeight: /*u32*/ number | undefined;
+};
+/**
+ * Generated factory for {@link ConfirmedExitNode} record objects.
+ */
+export declare const ConfirmedExitNode: Readonly<{
+    /**
+     * Create a frozen instance of {@link ConfirmedExitNode}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<ConfirmedExitNode> & Required<Omit<ConfirmedExitNode, never>>) => ConfirmedExitNode;
+    /**
+     * Create a frozen instance of {@link ConfirmedExitNode}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<ConfirmedExitNode> & Required<Omit<ConfirmedExitNode, never>>) => ConfirmedExitNode;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<ConfirmedExitNode>;
+}>;
 export type ConnectRequest = {
     config: Config;
     seed: Seed;
@@ -1854,6 +1955,38 @@ export declare const Credentials: Readonly<{
      */
     defaults: () => Partial<Credentials>;
 }>;
+/**
+ * A Spark-side asset a route accepts, with the amount bounds that apply to it.
+ *
+ * Bounds are per asset rather than per route: the same external endpoint can
+ * carry a dust floor when moved as sats and none when moved as a token.
+ */
+export type CrossChainAcceptedAsset = {
+    asset: SparkAsset;
+    /**
+     * Unset when the provider publishes no bounds for this pairing.
+     */
+    limits: CrossChainRouteLimits | undefined;
+};
+/**
+ * Generated factory for {@link CrossChainAcceptedAsset} record objects.
+ */
+export declare const CrossChainAcceptedAsset: Readonly<{
+    /**
+     * Create a frozen instance of {@link CrossChainAcceptedAsset}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<CrossChainAcceptedAsset> & Required<Omit<CrossChainAcceptedAsset, never>>) => CrossChainAcceptedAsset;
+    /**
+     * Create a frozen instance of {@link CrossChainAcceptedAsset}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<CrossChainAcceptedAsset> & Required<Omit<CrossChainAcceptedAsset, never>>) => CrossChainAcceptedAsset;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<CrossChainAcceptedAsset>;
+}>;
 export type CrossChainAddressDetails = {
     address: string;
     addressFamily: CrossChainAddressFamily;
@@ -1890,16 +2023,16 @@ export type CrossChainConfig = {
     /**
      * Default maximum slippage in basis points used when
      * [`PaymentRequest::CrossChain::max_slippage_bps`] is not set on the
-     * prepare request. Must be in `10..=500`. Falls back to 100 bps (1%)
-     * when this field is `None`.
+     * prepare request. Must be in 10 to 500. Falls back to 100 bps (1%)
+     * when this field is unset.
      */
     defaultSlippageBps: /*u32*/ number | undefined;
     /**
      * Default target-overpay pad in basis points applied to the user's
      * destination amount on `FeesExcluded` conversion sends. Bumps the
      * target upward before quoting so the recipient lands at or above the
-     * requested amount despite provider slippage. Must be in `0..=500`.
-     * Falls back to 15 bps when `None`.
+     * requested amount despite provider slippage. Must be in 0 to 500.
+     * Falls back to 15 bps when unset.
      */
     defaultTargetOverpayBps: /*u32*/ number | undefined;
 };
@@ -1922,6 +2055,131 @@ export declare const CrossChainConfig: Readonly<{
      */
     defaults: () => Partial<CrossChainConfig>;
 }>;
+/**
+ * Information about the cross-chain receive quote.
+ */
+export type CrossChainReceiveInfo = {
+    /**
+     * Bare external deposit address the sender pays to.
+     */
+    depositAddress: string;
+    /**
+     * Amount the sender must deposit, in source-asset base units
+     * (`route.decimals`). On `FeesExcluded` this may differ from the
+     * request's `amount` because the SDK inflates the deposit to absorb
+     * provider fees. Render this value to the sender.
+     */
+    depositAmount: U128;
+    /**
+     * Amount the receiver will see, net of provider fees, in
+     * destination-asset base units. Sats when receiving BTC into Spark,
+     * or token base units when receiving a Spark token (e.g. USDB). The
+     * final delivered amount may move within the slippage tolerance.
+     */
+    expectedReceivedAmount: U128;
+    /**
+     * Symbol of the Spark-side asset `expected_received_amount` is
+     * denominated in, as the provider reports it: `"BTC"` for sats, or the
+     * token symbol (e.g. `"USDB"`).
+     */
+    destinationAsset: string;
+    /**
+     * Spark token identifier when the destination is a token. Absent when
+     * the destination is BTC and the receiver will see sats.
+     */
+    tokenIdentifier: string | undefined;
+    /**
+     * Provider-quoted total fee for this receive, in `service_fee_asset`
+     * units.
+     */
+    serviceFeeAmount: U128;
+    /**
+     * Ticker for `service_fee_amount`. Absent when the fee is denominated
+     * in sats.
+     */
+    serviceFeeAsset: string | undefined;
+    /**
+     * Decimals of `service_fee_asset`, for formatting `service_fee_amount`.
+     * Unset when the fee is in sats or the provider did not report them.
+     */
+    serviceFeeAssetDecimals: /*u32*/ number | undefined;
+    /**
+     * Quote expiry as a unix timestamp in seconds.
+     */
+    expiresAt: bigint;
+};
+/**
+ * Generated factory for {@link CrossChainReceiveInfo} record objects.
+ */
+export declare const CrossChainReceiveInfo: Readonly<{
+    /**
+     * Create a frozen instance of {@link CrossChainReceiveInfo}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<CrossChainReceiveInfo> & Required<Omit<CrossChainReceiveInfo, never>>) => CrossChainReceiveInfo;
+    /**
+     * Create a frozen instance of {@link CrossChainReceiveInfo}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<CrossChainReceiveInfo> & Required<Omit<CrossChainReceiveInfo, never>>) => CrossChainReceiveInfo;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<CrossChainReceiveInfo>;
+}>;
+/**
+ * Amount bounds a provider publishes for moving a route with one Spark-side
+ * asset.
+ *
+ * A route can enforce a tighter bound than it publishes, so an amount inside
+ * these can still be rejected when the payment is prepared.
+ *
+ * The two groups are independent, and either can be absent: a route may
+ * publish a base-unit floor (a dust minimum on a sats-funded route), a USD
+ * notional band, both, or neither.
+ *
+ * `min_amount` / `max_amount` bound the asset that is paid in, so which asset
+ * they are denominated in follows the direction: the Spark-side asset on a
+ * send, the external asset on a receive. The USD band bounds the order's
+ * value and reads the same in both directions.
+ */
+export type CrossChainRouteLimits = {
+    /**
+     * Smallest amount accepted, in the base units of the asset paid in.
+     */
+    minAmount: U128 | undefined;
+    /**
+     * Largest amount accepted, in the base units of the asset paid in.
+     */
+    maxAmount: U128 | undefined;
+    /**
+     * Smallest order value accepted, in USD cents.
+     */
+    minUsdCents: /*u64*/ bigint | undefined;
+    /**
+     * Largest order value accepted, in USD cents.
+     */
+    maxUsdCents: /*u64*/ bigint | undefined;
+};
+/**
+ * Generated factory for {@link CrossChainRouteLimits} record objects.
+ */
+export declare const CrossChainRouteLimits: Readonly<{
+    /**
+     * Create a frozen instance of {@link CrossChainRouteLimits}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<CrossChainRouteLimits> & Required<Omit<CrossChainRouteLimits, never>>) => CrossChainRouteLimits;
+    /**
+     * Create a frozen instance of {@link CrossChainRouteLimits}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<CrossChainRouteLimits> & Required<Omit<CrossChainRouteLimits, never>>) => CrossChainRouteLimits;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<CrossChainRouteLimits>;
+}>;
 /**
  * A single route available for cross-chain transfers, tagged with the provider
  * that offers it. Returned by `get_cross_chain_routes()`.
@@ -1932,17 +2190,17 @@ export type CrossChainRoutePair = {
      */
     provider: CrossChainProvider;
     /**
-     * Destination blockchain (e.g. `"base"`, `"solana"`, `"tron"`).
+     * External blockchain (e.g. `"base"`, `"solana"`, `"tron"`).
      */
     chain: string;
     /**
-     * Stable chain identifier (e.g. EVM `chainId` as a decimal string).
+     * External chain identifier (e.g. EVM `chainId` as a decimal string).
      * `None` for non-EVM chains that don't expose one, or when the
      * provider doesn't surface it.
      */
     chainId: string | undefined;
     /**
-     * Destination asset symbol (e.g. `"USDC"`, `"USDT"`).
+     * External asset symbol (e.g. `"USDC"`, `"USDT"`).
      */
     asset: string;
     /**
@@ -1958,22 +2216,14 @@ export type CrossChainRoutePair = {
      */
     exactOutEligible: boolean;
     /**
-     * The source assets this route accepts on the Spark side.
-     *
-     * Boltz routes accept `[SourceAsset::Bitcoin]`. Orchestra routes accept
-     * one or more of `Bitcoin` / `Token(...)` (a given destination endpoint
-     * may be fronted by multiple source variants on Orchestra).
+     * Spark-side assets this route accepts, each with its own amount bounds.
      */
-    supportedSources: Array<SourceAsset>;
+    acceptedAssets: Array<CrossChainAcceptedAsset>;
     /**
-     * The chains this route can be paid over, orthogonal to
-     * `supported_sources` (the asset moved).
-     *
-     * This is the actual funding rail, which differs by provider: Boltz routes
-     * are always paid over Lightning. Orchestra send routes report Spark, and
-     * Orchestra payment-link routes report Lightning.
+     * Rails this route can be delivered over, orthogonal to
+     * `accepted_assets` (the asset moved vs the rail moved on).
      */
-    supportedSourceChains: Array<SourceChain>;
+    deliveryMethods: Array<DeliveryMethod>;
 };
 /**
  * Generated factory for {@link CrossChainRoutePair} record objects.
@@ -2063,6 +2313,14 @@ export type DepositInfo = {
      * Unset when no instant claim has been attempted.
      */
     instantClaimStatus: InstantClaimStatus | undefined;
+    /**
+     * The fee ceiling standing for this deposit alone. It caps what may be paid
+     * to claim the deposit ahead of maturity. The claim at maturity runs under
+     * whichever is larger, this or the configured max deposit claim fee, so a
+     * ceiling set below that one does not hold the deposit back from it. Unset
+     * means the configured ceiling applies to both.
+     */
+    maxClaimFee: MaxFee | undefined;
 };
 /**
  * Generated factory for {@link DepositInfo} record objects.
@@ -2185,6 +2443,83 @@ export declare const EcdsaSignatureBytes: Readonly<{
      */
     defaults: () => Partial<EcdsaSignatureBytes>;
 }>;
+/**
+ * What the chain has already done to an exit's leaves, as
+ * `prepare_unilateral_exit` found it. Pass it back to `unilateral_exit`, which
+ * builds only the steps it does not cover.
+ */
+export type ExitChainState = {
+    /**
+     * Nodes whose transaction is on-chain.
+     */
+    confirmedNodes: Array<ConfirmedExitNode>;
+    /**
+     * Leaves whose refund reached the chain.
+     */
+    refunds: Array<ExitRefund>;
+    /**
+     * Leaves whose lineage was taken on-chain by a transaction the exit cannot
+     * continue from. Nothing further can be driven for them.
+     */
+    stoppedLeafIds: Array<string>;
+    /**
+     * Nodes a chain lookup could not read, so their state is unknown rather
+     * than absent. Transactions depending on them come back
+     * `ExitTransactionStatus::Unverified`.
+     */
+    unverifiedNodeIds: Array<string>;
+    /**
+     * Nodes taken to be on-chain on the operators' word, the chain itself being
+     * unreadable. Their spend is invisible, so anything built over them risks
+     * double-spending an output that is already gone.
+     */
+    unverifiableConfirmedNodeIds: Array<string>;
+};
+/**
+ * Generated factory for {@link ExitChainState} record objects.
+ */
+export declare const ExitChainState: Readonly<{
+    /**
+     * Create a frozen instance of {@link ExitChainState}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<ExitChainState> & Required<Omit<ExitChainState, never>>) => ExitChainState;
+    /**
+     * Create a frozen instance of {@link ExitChainState}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<ExitChainState> & Required<Omit<ExitChainState, never>>) => ExitChainState;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<ExitChainState>;
+}>;
+/**
+ * A leaf's refund as the chain shows it.
+ */
+export type ExitRefund = {
+    leafId: string;
+    state: ExitRefundState;
+};
+/**
+ * Generated factory for {@link ExitRefund} record objects.
+ */
+export declare const ExitRefund: Readonly<{
+    /**
+     * Create a frozen instance of {@link ExitRefund}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<ExitRefund> & Required<Omit<ExitRefund, never>>) => ExitRefund;
+    /**
+     * Create a frozen instance of {@link ExitRefund}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<ExitRefund> & Required<Omit<ExitRefund, never>>) => ExitRefund;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<ExitRefund>;
+}>;
 /**
  * Result of `export_unilateral_exit_state`: a self-contained copy of the
  * wallet's exit state, ready to be stored outside the wallet.
@@ -2475,6 +2810,32 @@ export declare const ExternalInputParser: Readonly<{
      */
     defaults: () => Partial<ExternalInputParser>;
 }>;
+/**
+ * FFI-safe representation of `spark_wallet::LeafSigningKey`: the leaf signing
+ * key derived from `derived_from`.
+ */
+export type ExternalLeafSigningKey = {
+    derivedFrom: ExternalTreeNodeId;
+};
+/**
+ * Generated factory for {@link ExternalLeafSigningKey} record objects.
+ */
+export declare const ExternalLeafSigningKey: Readonly<{
+    /**
+     * Create a frozen instance of {@link ExternalLeafSigningKey}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<ExternalLeafSigningKey> & Required<Omit<ExternalLeafSigningKey, never>>) => ExternalLeafSigningKey;
+    /**
+     * Create a frozen instance of {@link ExternalLeafSigningKey}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<ExternalLeafSigningKey> & Required<Omit<ExternalLeafSigningKey, never>>) => ExternalLeafSigningKey;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<ExternalLeafSigningKey>;
+}>;
 /**
  * FFI-safe representation of `spark_wallet::NewLeafKey`.
  */
@@ -3113,12 +3474,14 @@ export declare const ExternalStartedStaticDepositRefund: Readonly<{
     defaults: () => Partial<ExternalStartedStaticDepositRefund>;
 }>;
 /**
- * FFI-safe representation of `spark_wallet::TransferLeafInput`. Conveys the old
- * leaf id and the new (post-transfer) leaf id; the signer derives keys from them.
+ * FFI-safe representation of `spark_wallet::TransferLeafInput`. Conveys the
+ * leaf id, the key the leaf is held under and the new (post-transfer) leaf id;
+ * the signer derives the keys from them.
  */
 export type ExternalTransferLeafInput = {
     nodeId: ExternalTreeNodeId;
     newLeafId: ExternalTreeNodeId;
+    signingKey: ExternalLeafSigningKey;
 };
 /**
  * Generated factory for {@link ExternalTransferLeafInput} record objects.
@@ -5214,6 +5577,11 @@ export type PreparePaymentLinkResponse = {
      * denominates its fee in sats, Orchestra in the stablecoin.
      */
     serviceFeeAsset: string | undefined;
+    /**
+     * Decimals of `service_fee_asset`, for formatting `service_fee_amount`.
+     * Unset when the fee is in sats or the provider did not report them.
+     */
+    serviceFeeAssetDecimals: /*u32*/ number | undefined;
     /**
      * RFC3339 timestamp after which the quote is no longer valid.
      */
@@ -5426,6 +5794,11 @@ export declare const PrepareUnilateralExitRequest: Readonly<{
  * fee at the requested rate, and how much to fund.
  */
 export type PrepareUnilateralExitResponse = {
+    /**
+     * The leaves the exit covers. A leaf whose exit already finished is left out,
+     * even when named: `exit_chain_state` shows its refund swept or its branch
+     * stopped.
+     */
     leaves: Array<UnilateralExitLeaf>;
     /**
      * Total value of the selected leaves, in satoshis.
@@ -5436,16 +5809,34 @@ export type PrepareUnilateralExitResponse = {
      * branches), in satoshis. Exact for the given funding kind; nodes the
      * operators report on-chain are assumed already paid, so a partially-exited
      * tree quotes a lower fee than a fresh one.
+     *
+     * The sum of the three components below, which say who pays what:
+     * `cpfp_fee_sat + fanout_fee_sat + sweep_fee_sat`. The first two come from
+     * your funding UTXO, the third off the value being recovered.
      */
     totalFeeSat: bigint;
     /**
-     * The part of `total_fee_sat` paid for the fan-out transaction. Funding one
-     * UTXO per branch (`per_branch_funding`) avoids it. Zero for a single
-     * branch (no fan-out).
+     * The part of `total_fee_sat` the CPFP children pay, funded by your UTXOs.
+     * It does not reduce what the exit recovers.
+     */
+    cpfpFeeSat: bigint;
+    /**
+     * The part of `total_fee_sat` paid for the fan-out transaction, funded by
+     * your UTXO. Funding one UTXO per branch (`per_branch_funding`) avoids it.
+     * Zero for a single branch (no fan-out).
      */
     fanoutFeeSat: bigint;
+    /**
+     * The part of `total_fee_sat` the final sweep pays. The sweep takes its fee
+     * from the value it moves, so this is the one component subtracted from
+     * what reaches `destination`.
+     */
+    sweepFeeSat: bigint;
     /**
      * Fund a single UTXO of at least this many satoshis to exit with a fan-out.
+     * Above `cpfp_fee_sat + fanout_fee_sat` by design: it carries the sweep fee
+     * and a per-branch dust allowance as headroom, both of which come back to
+     * you in the sweep.
      */
     singleUtxoFundingSat: bigint;
     /**
@@ -5458,6 +5849,12 @@ export type PrepareUnilateralExitResponse = {
      */
     feeRateSatPerVbyte: bigint;
     destination: string;
+    /**
+     * What the chain has already done to these leaves, read while preparing.
+     * Pass it back to `unilateral_exit`, which builds only the steps it does
+     * not already cover.
+     */
+    exitChainState: ExitChainState;
 };
 /**
  * Generated factory for {@link PrepareUnilateralExitResponse} record objects.
@@ -5680,6 +6077,10 @@ export type ReceivePaymentResponse = {
      * Denominated in sats or token base units
      */
     fee: U128;
+    /**
+     * Optional information populated only for cross-chain receives.
+     */
+    crossChainInfo: CrossChainReceiveInfo | undefined;
 };
 /**
  * Generated factory for {@link ReceivePaymentResponse} record objects.
@@ -6287,11 +6688,26 @@ export declare const SendBatchResponse: Readonly<{
     defaults: () => Partial<SendBatchResponse>;
 }>;
 export type SendOnchainFeeQuote = {
+    /**
+     * Identifies the quote to the provider when the payment is sent. Empty on
+     * an estimate, which no provider has issued.
+     */
     id: string;
+    /**
+     * When the quote stops being honoured, as a Unix timestamp in seconds.
+     * Zero on an estimate.
+     */
     expiresAt: bigint;
     speedFast: SendOnchainSpeedFeeQuote;
     speedMedium: SendOnchainSpeedFeeQuote;
     speedSlow: SendOnchainSpeedFeeQuote;
+    /**
+     * Set when the wallet holds no bitcoin and a token conversion will fund the
+     * send, because the provider will not quote without funds to price against.
+     * The estimate is an upper bound: the payment quotes for real once the
+     * conversion lands, and fails rather than spending more than this.
+     */
+    isEstimate: boolean;
 };
 /**
  * Generated factory for {@link SendOnchainFeeQuote} record objects.
@@ -7051,9 +7467,8 @@ export declare const SparkStatus: Readonly<{
  * Configuration for automatic conversion of Bitcoin to stable tokens.
  *
  * When configured, the SDK automatically monitors the Bitcoin balance after each
- * wallet sync. When the balance exceeds the configured threshold plus the reserved
- * amount, the SDK automatically converts the excess balance (above the reserve)
- * to the active stable token.
+ * wallet sync. Once the balance reaches the configured threshold, the SDK converts
+ * the whole Bitcoin balance to the active stable token.
  *
  * When the balance is held in a stable token, Bitcoin payments can still be sent.
  * The SDK automatically detects when there's not enough Bitcoin balance to cover a
@@ -7503,6 +7918,7 @@ export type TurnkeyConfig = {
     /**
      * Network the wallet operates on; selects the Spark address format
      * (mainnet or regtest) used for Spark-protocol and Schnorr signing.
+     * Signet is unsupported by Turnkey's Spark account formats.
      */
     network: Network;
     /**
@@ -7761,14 +8177,43 @@ export type UnilateralExitResponse = {
      * The actual total on-chain fee the returned transactions pay at the
      * requested rate, in satoshis. A resumed or partially-confirmed exit pays
      * less because already-confirmed steps are not rebuilt.
+     *
+     * The sum of the three components below, which say who pays what:
+     * `cpfp_fee_sat + fanout_fee_sat + sweep_fee_sat`. The first two come from
+     * your funding UTXOs, the third off the value being recovered.
      */
     totalFeeSat: bigint;
+    /**
+     * The part of `total_fee_sat` the CPFP children pay, funded by your UTXOs.
+     * It does not reduce what the exit recovers.
+     */
+    cpfpFeeSat: bigint;
+    /**
+     * The part of `total_fee_sat` the fan-out pays, funded by your UTXO. Zero
+     * when this exit needed no fan-out, and when an earlier attempt's fan-out
+     * had already confirmed.
+     */
+    fanoutFeeSat: bigint;
+    /**
+     * The part of `total_fee_sat` the sweep pays, taken from the value it
+     * moves, so this is the one component subtracted from what reaches the
+     * destination. Zero while no refund is on-chain yet and the set carries no
+     * sweep.
+     */
+    sweepFeeSat: bigint;
     leaves: Array<UnilateralExitLeaf>;
     /**
      * The full signed transaction set, in valid topological (broadcast) order
      * with shared ancestors appearing once and the sweep last.
      */
     transactions: Array<UnilateralExitTransaction>;
+    /**
+     * The funding UTXOs this exit was built from, as you supplied them. Hand
+     * them back when you build the exit again and they are followed to whatever
+     * they have since become, so an outpoint an earlier attempt already spent
+     * still funds the rest.
+     */
+    fundingInputs: Array<CpfpInput>;
 };
 /**
  * Generated factory for {@link UnilateralExitResponse} record objects.
@@ -7818,7 +8263,12 @@ export type UnilateralExitTransaction = {
      * one can be broadcast.
      */
     dependsOn: Array<string>;
-    status: ConfirmationStatus;
+    /**
+     * Whether this transaction is on-chain, can go out now, or is waiting on
+     * something. Resolved against the chain tip, so it accounts for
+     * `csv_timelock_blocks` as well as `depends_on`.
+     */
+    status: ExitTransactionStatus;
 };
 /**
  * Generated factory for {@link UnilateralExitTransaction} record objects.
@@ -8105,6 +8555,40 @@ export declare const WalletSetup: Readonly<{
      */
     defaults: () => Partial<WalletSetup>;
 }>;
+/**
+ * A static deposit address being watched on-chain for unconfirmed deposits.
+ */
+export type WatchedDepositAddress = {
+    address: string;
+    /**
+     * When the address was handed out, in seconds since the epoch. The watch
+     * window is measured from here.
+     */
+    issuedAt: bigint;
+    /**
+     * Whether a deposit to it has been seen unconfirmed.
+     */
+    seen: boolean;
+};
+/**
+ * Generated factory for {@link WatchedDepositAddress} record objects.
+ */
+export declare const WatchedDepositAddress: Readonly<{
+    /**
+     * Create a frozen instance of {@link WatchedDepositAddress}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<WatchedDepositAddress> & Required<Omit<WatchedDepositAddress, never>>) => WatchedDepositAddress;
+    /**
+     * Create a frozen instance of {@link WatchedDepositAddress}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<WatchedDepositAddress> & Required<Omit<WatchedDepositAddress, never>>) => WatchedDepositAddress;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<WatchedDepositAddress>;
+}>;
 /**
  * A registered webhook entry.
  */
@@ -8974,6 +9458,7 @@ export declare enum ChainApiType {
 export declare enum ChainServiceError_Tags {
     InvalidAddress = "InvalidAddress",
     ServiceConnectivity = "ServiceConnectivity",
+    NotFound = "NotFound",
     Generic = "Generic"
 }
 export declare const ChainServiceError: Readonly<{
@@ -9120,9 +9605,9 @@ export declare const ChainServiceError: Readonly<{
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
         stackTraceLimit: number;
     };
-    Generic: {
+    NotFound: {
         new (v0: string): {
-            readonly tag: ChainServiceError_Tags.Generic;
+            readonly tag: ChainServiceError_Tags.NotFound;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -9135,7 +9620,7 @@ export declare const ChainServiceError: Readonly<{
             cause?: unknown;
         };
         "new"(v0: string): {
-            readonly tag: ChainServiceError_Tags.Generic;
+            readonly tag: ChainServiceError_Tags.NotFound;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -9148,7 +9633,78 @@ export declare const ChainServiceError: Readonly<{
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: ChainServiceError_Tags.Generic;
+            readonly tag: ChainServiceError_Tags.NotFound;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ChainServiceError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ChainServiceError_Tags.NotFound;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ChainServiceError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ChainServiceError_Tags.NotFound;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ChainServiceError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    Generic: {
+        new (v0: string): {
+            readonly tag: ChainServiceError_Tags.Generic;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ChainServiceError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: ChainServiceError_Tags.Generic;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ChainServiceError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ChainServiceError_Tags.Generic;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -9193,24 +9749,257 @@ export declare const ChainServiceError: Readonly<{
     };
 }>;
 export type ChainServiceError = InstanceType<(typeof ChainServiceError)[keyof Omit<typeof ChainServiceError, 'instanceOf'>]>;
+export declare enum ClaimDeferredReason_Tags {
+    MaxFeeExceeded = "MaxFeeExceeded",
+    NoEarlyClaimAvailable = "NoEarlyClaimAvailable",
+    ProviderDeclined = "ProviderDeclined"
+}
 /**
- * Whether a transaction in the exit path is already on-chain.
+ * Why a claim was deferred rather than made.
  */
-export declare enum ConfirmationStatus {
-    /**
-     * This transaction is confirmed in a block. It needs no action.
-     */
-    Confirmed = 0,
-    /**
-     * This transaction is not yet confirmed. Mempool state is not consulted.
-     */
-    Unconfirmed = 1,
-    /**
-     * The on-chain status could not be determined (the chain service errored).
-     * Broadcasting may fail if a conflicting transaction already landed.
-     */
-    Unverified = 2
+export declare const ClaimDeferredReason: Readonly<{
+    instanceOf: (obj: any) => obj is ClaimDeferredReason;
+    MaxFeeExceeded: {
+        new (inner: {
+            /**
+             * What the provider asked to credit the deposit early.
+             */ requiredFeeSats: bigint;
+            /**
+             * The ceiling it was held to.
+             */ maxFeeSats: bigint;
+        }): {
+            readonly tag: ClaimDeferredReason_Tags.MaxFeeExceeded;
+            readonly inner: Readonly<{
+                requiredFeeSats: bigint;
+                maxFeeSats: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+        "new"(inner: {
+            /**
+             * What the provider asked to credit the deposit early.
+             */ requiredFeeSats: bigint;
+            /**
+             * The ceiling it was held to.
+             */ maxFeeSats: bigint;
+        }): {
+            readonly tag: ClaimDeferredReason_Tags.MaxFeeExceeded;
+            readonly inner: Readonly<{
+                requiredFeeSats: bigint;
+                maxFeeSats: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ClaimDeferredReason_Tags.MaxFeeExceeded;
+            readonly inner: Readonly<{
+                requiredFeeSats: bigint;
+                maxFeeSats: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+    };
+    NoEarlyClaimAvailable: {
+        new (): {
+            readonly tag: ClaimDeferredReason_Tags.NoEarlyClaimAvailable;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+        "new"(): {
+            readonly tag: ClaimDeferredReason_Tags.NoEarlyClaimAvailable;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ClaimDeferredReason_Tags.NoEarlyClaimAvailable;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+    };
+    ProviderDeclined: {
+        new (inner: {
+            message: string;
+        }): {
+            readonly tag: ClaimDeferredReason_Tags.ProviderDeclined;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+        "new"(inner: {
+            message: string;
+        }): {
+            readonly tag: ClaimDeferredReason_Tags.ProviderDeclined;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ClaimDeferredReason_Tags.ProviderDeclined;
+            readonly inner: Readonly<{
+                message: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDeferredReason";
+        };
+    };
+}>;
+/**
+ * Why a claim was deferred rather than made.
+ */
+export type ClaimDeferredReason = InstanceType<(typeof ClaimDeferredReason)[keyof Omit<typeof ClaimDeferredReason, 'instanceOf'>]>;
+export declare enum ClaimDepositOutcome_Tags {
+    Settled = "Settled",
+    Submitted = "Submitted",
+    Deferred = "Deferred"
 }
+/**
+ * What became of a claim.
+ */
+export declare const ClaimDepositOutcome: Readonly<{
+    instanceOf: (obj: any) => obj is ClaimDepositOutcome;
+    Settled: {
+        new (inner: {
+            payment: Payment;
+        }): {
+            readonly tag: ClaimDepositOutcome_Tags.Settled;
+            readonly inner: Readonly<{
+                payment: Payment;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+        "new"(inner: {
+            payment: Payment;
+        }): {
+            readonly tag: ClaimDepositOutcome_Tags.Settled;
+            readonly inner: Readonly<{
+                payment: Payment;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ClaimDepositOutcome_Tags.Settled;
+            readonly inner: Readonly<{
+                payment: Payment;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+    };
+    Submitted: {
+        new (): {
+            readonly tag: ClaimDepositOutcome_Tags.Submitted;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+        "new"(): {
+            readonly tag: ClaimDepositOutcome_Tags.Submitted;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ClaimDepositOutcome_Tags.Submitted;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+    };
+    Deferred: {
+        new (inner: {
+            reason: ClaimDeferredReason;
+        }): {
+            readonly tag: ClaimDepositOutcome_Tags.Deferred;
+            readonly inner: Readonly<{
+                reason: ClaimDeferredReason;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+        "new"(inner: {
+            reason: ClaimDeferredReason;
+        }): {
+            readonly tag: ClaimDepositOutcome_Tags.Deferred;
+            readonly inner: Readonly<{
+                reason: ClaimDeferredReason;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ClaimDepositOutcome_Tags.Deferred;
+            readonly inner: Readonly<{
+                reason: ClaimDeferredReason;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ClaimDepositOutcome";
+        };
+    };
+}>;
+/**
+ * What became of a claim.
+ */
+export type ClaimDepositOutcome = InstanceType<(typeof ClaimDepositOutcome)[keyof Omit<typeof ClaimDepositOutcome, 'instanceOf'>]>;
 export declare enum ConversionChain_Tags {
     Spark = "Spark",
     Lightning = "Lightning",
@@ -9364,8 +10153,9 @@ export declare enum ConversionInfo_Tags {
  *
  * The variant identifies which provider handled the conversion:
  * - [`ConversionInfo::Amm`] for Spark token swaps via Flashnet AMM pools.
- * - [`ConversionInfo::Orchestra`] for cross-chain sends via Flashnet
- * Orchestra (Spark → external chain).
+ * - [`ConversionInfo::Orchestra`] for cross-chain transfers via Flashnet
+ * Orchestra, in either direction (Spark → external chain, or external
+ * chain → Spark).
  * - [`ConversionInfo::Boltz`] for sats → stable-coin reverse swaps via Boltz.
  */
 export declare const ConversionInfo: Readonly<{
@@ -9494,21 +10284,33 @@ export declare const ConversionInfo: Readonly<{
              * Asset ticker (e.g. `"USDC"`, `"USDT"`).
              */ asset: string;
             /**
-             * Recipient address on the target chain.
+             * The target-chain address on a send, the receiving Spark address
+             * on a receive.
              */ recipientAddress: string;
             /**
-             * Amount in expressed in the cross-chain asset's base units, via
-             * the rate the SDK used at prepare time.
+             * Amount paid in, in `asset` base units. On a send it is the Spark
+             * amount expressed in `asset` via the rate the SDK used at prepare
+             * time. On a receive it is the deposit the sender made on `chain`.
              */ assetAmountIn: U128 | undefined;
             /**
-             * Estimated recipient amount, frozen at prepare time.
+             * Estimated amount delivered to the receiving end, frozen at prepare
+             * time. In `asset` base units on a send, and in Spark-side units on
+             * a receive (sats for Bitcoin, token base units for a token).
              */ estimatedOut: U128;
             /**
-             * Actual delivered amount, Unset until the order reaches a terminal state.
+             * Actual delivered amount, in the same units as `estimated_out`.
+             * Unset until the order reaches a terminal state.
              */ deliveredAmount: U128 | undefined;
+            /**
+             * Transaction on `chain`, the non-Spark side of the conversion: the
+             * delivery on a send, the funding deposit on a receive. Format follows
+             * the chain (e.g. `0x`-prefixed hex on EVM, a base58 signature on
+             * Solana). Unset until that transaction exists, and on orders that
+             * failed or were refunded.
+             */ externalTxHash: string | undefined;
             status: ConversionStatus;
             /**
-             * Best-available total fee in destination asset base units.
+             * Best-available total fee, in `asset` base units.
              * Prepare-time estimate while pending, realized fee when Completed.
              */ feeAmount: U128 | undefined;
             /**
@@ -9517,11 +10319,16 @@ export declare const ConversionInfo: Readonly<{
             /**
              * Asset the service fee is denominated in. Unset means BTC sats.
              */ serviceFeeAsset: string | undefined;
+            /**
+             * Decimals of `service_fee_asset`, for formatting `service_fee_amount`.
+             * Unset when the fee is in sats or the provider did not report them.
+             */ serviceFeeAssetDecimals: /*u32*/ number | undefined;
             /**
              * Asset decimals (e.g. 6 for USDC).
              */ assetDecimals: number;
             /**
-             * Token contract / mint address. Unset for native-asset destinations.
+             * Token contract / mint address on `chain`. Unset when that side is
+             * the chain's native asset.
              */ assetContract: string | undefined;
         }): {
             readonly tag: ConversionInfo_Tags.Orchestra;
@@ -9536,10 +10343,12 @@ export declare const ConversionInfo: Readonly<{
                 assetAmountIn: U128 | undefined;
                 estimatedOut: U128;
                 deliveredAmount: U128 | undefined;
+                externalTxHash: string | undefined;
                 status: ConversionStatus;
                 feeAmount: U128 | undefined;
                 serviceFeeAmount: U128 | undefined;
                 serviceFeeAsset: string | undefined;
+                serviceFeeAssetDecimals: /*u32*/ number | undefined;
                 assetDecimals: number;
                 assetContract: string | undefined;
             }>;
@@ -9571,21 +10380,33 @@ export declare const ConversionInfo: Readonly<{
              * Asset ticker (e.g. `"USDC"`, `"USDT"`).
              */ asset: string;
             /**
-             * Recipient address on the target chain.
+             * The target-chain address on a send, the receiving Spark address
+             * on a receive.
              */ recipientAddress: string;
             /**
-             * Amount in expressed in the cross-chain asset's base units, via
-             * the rate the SDK used at prepare time.
+             * Amount paid in, in `asset` base units. On a send it is the Spark
+             * amount expressed in `asset` via the rate the SDK used at prepare
+             * time. On a receive it is the deposit the sender made on `chain`.
              */ assetAmountIn: U128 | undefined;
             /**
-             * Estimated recipient amount, frozen at prepare time.
+             * Estimated amount delivered to the receiving end, frozen at prepare
+             * time. In `asset` base units on a send, and in Spark-side units on
+             * a receive (sats for Bitcoin, token base units for a token).
              */ estimatedOut: U128;
             /**
-             * Actual delivered amount, Unset until the order reaches a terminal state.
+             * Actual delivered amount, in the same units as `estimated_out`.
+             * Unset until the order reaches a terminal state.
              */ deliveredAmount: U128 | undefined;
+            /**
+             * Transaction on `chain`, the non-Spark side of the conversion: the
+             * delivery on a send, the funding deposit on a receive. Format follows
+             * the chain (e.g. `0x`-prefixed hex on EVM, a base58 signature on
+             * Solana). Unset until that transaction exists, and on orders that
+             * failed or were refunded.
+             */ externalTxHash: string | undefined;
             status: ConversionStatus;
             /**
-             * Best-available total fee in destination asset base units.
+             * Best-available total fee, in `asset` base units.
              * Prepare-time estimate while pending, realized fee when Completed.
              */ feeAmount: U128 | undefined;
             /**
@@ -9594,11 +10415,16 @@ export declare const ConversionInfo: Readonly<{
             /**
              * Asset the service fee is denominated in. Unset means BTC sats.
              */ serviceFeeAsset: string | undefined;
+            /**
+             * Decimals of `service_fee_asset`, for formatting `service_fee_amount`.
+             * Unset when the fee is in sats or the provider did not report them.
+             */ serviceFeeAssetDecimals: /*u32*/ number | undefined;
             /**
              * Asset decimals (e.g. 6 for USDC).
              */ assetDecimals: number;
             /**
-             * Token contract / mint address. Unset for native-asset destinations.
+             * Token contract / mint address on `chain`. Unset when that side is
+             * the chain's native asset.
              */ assetContract: string | undefined;
         }): {
             readonly tag: ConversionInfo_Tags.Orchestra;
@@ -9613,10 +10439,12 @@ export declare const ConversionInfo: Readonly<{
                 assetAmountIn: U128 | undefined;
                 estimatedOut: U128;
                 deliveredAmount: U128 | undefined;
+                externalTxHash: string | undefined;
                 status: ConversionStatus;
                 feeAmount: U128 | undefined;
                 serviceFeeAmount: U128 | undefined;
                 serviceFeeAsset: string | undefined;
+                serviceFeeAssetDecimals: /*u32*/ number | undefined;
                 assetDecimals: number;
                 assetContract: string | undefined;
             }>;
@@ -9639,10 +10467,12 @@ export declare const ConversionInfo: Readonly<{
                 assetAmountIn: U128 | undefined;
                 estimatedOut: U128;
                 deliveredAmount: U128 | undefined;
+                externalTxHash: string | undefined;
                 status: ConversionStatus;
                 feeAmount: U128 | undefined;
                 serviceFeeAmount: U128 | undefined;
                 serviceFeeAsset: string | undefined;
+                serviceFeeAssetDecimals: /*u32*/ number | undefined;
                 assetDecimals: number;
                 assetContract: string | undefined;
             }>;
@@ -9716,7 +10546,8 @@ export declare const ConversionInfo: Readonly<{
              * Asset decimals (e.g. 6 for USDT).
              */ assetDecimals: number;
             /**
-             * Token contract / mint address. Unset for native-asset destinations.
+             * Token contract / mint address on `chain`. Unset when that side is
+             * the chain's native asset.
              */ assetContract: string | undefined;
         }): {
             readonly tag: ConversionInfo_Tags.Boltz;
@@ -9809,7 +10640,8 @@ export declare const ConversionInfo: Readonly<{
              * Asset decimals (e.g. 6 for USDT).
              */ assetDecimals: number;
             /**
-             * Token contract / mint address. Unset for native-asset destinations.
+             * Token contract / mint address on `chain`. Unset when that side is
+             * the chain's native asset.
              */ assetContract: string | undefined;
         }): {
             readonly tag: ConversionInfo_Tags.Boltz;
@@ -9877,8 +10709,9 @@ export declare const ConversionInfo: Readonly<{
  *
  * The variant identifies which provider handled the conversion:
  * - [`ConversionInfo::Amm`] for Spark token swaps via Flashnet AMM pools.
- * - [`ConversionInfo::Orchestra`] for cross-chain sends via Flashnet
- * Orchestra (Spark → external chain).
+ * - [`ConversionInfo::Orchestra`] for cross-chain transfers via Flashnet
+ * Orchestra, in either direction (Spark → external chain, or external
+ * chain → Spark).
  * - [`ConversionInfo::Boltz`] for sats → stable-coin reverse swaps via Boltz.
  */
 export type ConversionInfo = InstanceType<(typeof ConversionInfo)[keyof Omit<typeof ConversionInfo, 'instanceOf'>]>;
@@ -10409,19 +11242,34 @@ export declare enum CrossChainAddressFamily {
     Tron = 2
 }
 /**
- * How the caller wants fees handled against the request `amount`.
- *
- * - `FeesExcluded`: `amount` is the provider invoice/deposit target; the
- * wallet pays `amount + source_transfer_fee_sats` in total.
- * - `FeesIncluded`: `amount` is the wallet's total sats budget; the provider
- * leg is sized so `amount_in + source_transfer_fee_sats <= amount`.
+ * Which side of the transfer the request `amount` sizes: what leaves the
+ * payer, or what reaches the receiver.
  */
 export declare enum CrossChainFeeMode {
+    /**
+     * `amount` sizes the receiving end, and fees are paid on top.
+     *
+     * Sending: `amount` is the provider invoice/deposit target, and the
+     * wallet pays `amount + source_transfer_fee_sats` in total.
+     * Receiving: `amount` is what the wallet ends up with, and the deposit
+     * the sender is asked for is sized above it to cover fees.
+     */
     FeesExcluded = 0,
+    /**
+     * `amount` sizes the paying end, and fees come out of it.
+     *
+     * Sending: `amount` is the wallet's total sats budget, and the provider
+     * leg is sized so `amount_in + source_transfer_fee_sats <= amount`.
+     * Receiving: `amount` is the deposit the sender makes, and the wallet
+     * ends up with that minus fees.
+     */
     FeesIncluded = 1
 }
 export declare enum CrossChainProvider {
     Orchestra = 0,
+    /**
+     * Not operational: no routes are currently offered under this provider.
+     */
     Boltz = 1
 }
 export declare enum CrossChainProviderContext_Tags {
@@ -10707,6 +11555,23 @@ export declare const CrossChainRouteFilter: Readonly<{
  * `get_cross_chain_routes()` API.
  */
 export type CrossChainRouteFilter = InstanceType<(typeof CrossChainRouteFilter)[keyof Omit<typeof CrossChainRouteFilter, 'instanceOf'>]>;
+/**
+ * The rail a cross-chain payment is delivered over.
+ */
+export declare enum DeliveryMethod {
+    /**
+     * Delivered over the Spark network.
+     */
+    Spark = 0,
+    /**
+     * Delivered over Lightning.
+     */
+    Lightning = 1,
+    /**
+     * Delivered on-chain over Bitcoin.
+     */
+    Bitcoin = 2
+}
 export declare enum DepositClaimError_Tags {
     MaxDepositClaimFeeExceeded = "MaxDepositClaimFeeExceeded",
     MissingUtxo = "MissingUtxo",
@@ -11067,53 +11932,330 @@ export declare const ExitLeafSelection: Readonly<{
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+    };
+    Specific: {
+        new (inner: {
+            leafIds: Array<string>;
+        }): {
+            readonly tag: ExitLeafSelection_Tags.Specific;
+            readonly inner: Readonly<{
+                leafIds: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+        "new"(inner: {
+            leafIds: Array<string>;
+        }): {
+            readonly tag: ExitLeafSelection_Tags.Specific;
+            readonly inner: Readonly<{
+                leafIds: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitLeafSelection_Tags.Specific;
+            readonly inner: Readonly<{
+                leafIds: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+    };
+}>;
+/**
+ * Which leaves to exit.
+ */
+export type ExitLeafSelection = InstanceType<(typeof ExitLeafSelection)[keyof Omit<typeof ExitLeafSelection, 'instanceOf'>]>;
+/**
+ * Which of a node's two pre-signed spends took it on-chain.
+ */
+export declare enum ExitNodeConfirmation {
+    /**
+     * The CPFP transaction, whose fee a child paid.
+     */
+    Cpfp = 0,
+    /**
+     * The direct transaction, which pays its own fee. A leaf that went out this
+     * way is refunded by its direct refund transaction.
+     */
+    Direct = 1
+}
+export declare enum ExitRefundState_Tags {
+    OnChain = "OnChain",
+    Swept = "Swept"
+}
+export declare const ExitRefundState: Readonly<{
+    instanceOf: (obj: any) => obj is ExitRefundState;
+    OnChain: {
+        new (inner: {
+            txHex: string;
+            vout: number;
+            valueSat: bigint;
+            blockHeight: /*u32*/ number | undefined;
+        }): {
+            readonly tag: ExitRefundState_Tags.OnChain;
+            readonly inner: Readonly<{
+                txHex: string;
+                vout: number;
+                valueSat: bigint;
+                blockHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitRefundState";
+        };
+        "new"(inner: {
+            txHex: string;
+            vout: number;
+            valueSat: bigint;
+            blockHeight: /*u32*/ number | undefined;
+        }): {
+            readonly tag: ExitRefundState_Tags.OnChain;
+            readonly inner: Readonly<{
+                txHex: string;
+                vout: number;
+                valueSat: bigint;
+                blockHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitRefundState";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitRefundState_Tags.OnChain;
+            readonly inner: Readonly<{
+                txHex: string;
+                vout: number;
+                valueSat: bigint;
+                blockHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitRefundState";
+        };
+    };
+    Swept: {
+        new (): {
+            readonly tag: ExitRefundState_Tags.Swept;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitRefundState";
+        };
+        "new"(): {
+            readonly tag: ExitRefundState_Tags.Swept;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitRefundState";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitRefundState_Tags.Swept;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitRefundState";
+        };
+    };
+}>;
+export type ExitRefundState = InstanceType<(typeof ExitRefundState)[keyof Omit<typeof ExitRefundState, 'instanceOf'>]>;
+export declare enum ExitTransactionStatus_Tags {
+    Confirmed = "Confirmed",
+    Ready = "Ready",
+    WaitingForDependencies = "WaitingForDependencies",
+    WaitingForTimelock = "WaitingForTimelock",
+    Unverified = "Unverified"
+}
+/**
+ * Where a transaction in the exit path stands: on-chain, ready to send, or
+ * waiting for something.
+ */
+export declare const ExitTransactionStatus: Readonly<{
+    instanceOf: (obj: any) => obj is ExitTransactionStatus;
+    Confirmed: {
+        new (inner: {
+            blockHeight: /*u32*/ number | undefined;
+        }): {
+            readonly tag: ExitTransactionStatus_Tags.Confirmed;
+            readonly inner: Readonly<{
+                blockHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+        "new"(inner: {
+            blockHeight: /*u32*/ number | undefined;
+        }): {
+            readonly tag: ExitTransactionStatus_Tags.Confirmed;
+            readonly inner: Readonly<{
+                blockHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitTransactionStatus_Tags.Confirmed;
+            readonly inner: Readonly<{
+                blockHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+    };
+    Ready: {
+        new (): {
+            readonly tag: ExitTransactionStatus_Tags.Ready;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+        "new"(): {
+            readonly tag: ExitTransactionStatus_Tags.Ready;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitTransactionStatus_Tags.Ready;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+    };
+    WaitingForDependencies: {
+        new (): {
+            readonly tag: ExitTransactionStatus_Tags.WaitingForDependencies;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+        "new"(): {
+            readonly tag: ExitTransactionStatus_Tags.WaitingForDependencies;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitTransactionStatus_Tags.WaitingForDependencies;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+    };
+    WaitingForTimelock: {
+        new (inner: {
+            spendableAtHeight: /*u32*/ number | undefined;
+        }): {
+            readonly tag: ExitTransactionStatus_Tags.WaitingForTimelock;
+            readonly inner: Readonly<{
+                spendableAtHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+        "new"(inner: {
+            spendableAtHeight: /*u32*/ number | undefined;
+        }): {
+            readonly tag: ExitTransactionStatus_Tags.WaitingForTimelock;
+            readonly inner: Readonly<{
+                spendableAtHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitTransactionStatus_Tags.WaitingForTimelock;
+            readonly inner: Readonly<{
+                spendableAtHeight: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
         };
     };
-    Specific: {
-        new (inner: {
-            leafIds: Array<string>;
-        }): {
-            readonly tag: ExitLeafSelection_Tags.Specific;
-            readonly inner: Readonly<{
-                leafIds: Array<string>;
-            }>;
+    Unverified: {
+        new (): {
+            readonly tag: ExitTransactionStatus_Tags.Unverified;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
         };
-        "new"(inner: {
-            leafIds: Array<string>;
-        }): {
-            readonly tag: ExitLeafSelection_Tags.Specific;
-            readonly inner: Readonly<{
-                leafIds: Array<string>;
-            }>;
+        "new"(): {
+            readonly tag: ExitTransactionStatus_Tags.Unverified;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: ExitLeafSelection_Tags.Specific;
-            readonly inner: Readonly<{
-                leafIds: Array<string>;
-            }>;
+            readonly tag: ExitTransactionStatus_Tags.Unverified;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+            readonly [uniffiTypeNameSymbol]: "ExitTransactionStatus";
         };
     };
 }>;
 /**
- * Which leaves to exit.
+ * Where a transaction in the exit path stands: on-chain, ready to send, or
+ * waiting for something.
  */
-export type ExitLeafSelection = InstanceType<(typeof ExitLeafSelection)[keyof Omit<typeof ExitLeafSelection, 'instanceOf'>]>;
+export type ExitTransactionStatus = InstanceType<(typeof ExitTransactionStatus)[keyof Omit<typeof ExitTransactionStatus, 'instanceOf'>]>;
 export declare enum ExternalFrostDerivation_Tags {
     SigningLeaf = "SigningLeaf",
     StaticDeposit = "StaticDeposit",
@@ -11842,7 +12984,8 @@ export declare const InputType: Readonly<{
 export type InputType = InstanceType<(typeof InputType)[keyof Omit<typeof InputType, 'instanceOf'>]>;
 export declare enum InstantClaimStatus_Tags {
     Declined = "Declined",
-    Submitted = "Submitted"
+    Submitted = "Submitted",
+    Claimed = "Claimed"
 }
 /**
  * State of an instant claim attempt on a deposit.
@@ -11932,6 +13075,32 @@ export declare const InstantClaimStatus: Readonly<{
             readonly [uniffiTypeNameSymbol]: "InstantClaimStatus";
         };
     };
+    Claimed: {
+        new (): {
+            readonly tag: InstantClaimStatus_Tags.Claimed;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InstantClaimStatus";
+        };
+        "new"(): {
+            readonly tag: InstantClaimStatus_Tags.Claimed;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InstantClaimStatus";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: InstantClaimStatus_Tags.Claimed;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InstantClaimStatus";
+        };
+    };
 }>;
 /**
  * State of an instant claim attempt on a deposit.
@@ -12144,7 +13313,8 @@ export declare const MaxFee: Readonly<{
 export type MaxFee = InstanceType<(typeof MaxFee)[keyof Omit<typeof MaxFee, 'instanceOf'>]>;
 export declare enum Network {
     Mainnet = 0,
-    Regtest = 1
+    Regtest = 1,
+    Signet = 2
 }
 export declare enum OnchainConfirmationSpeed {
     Fast = 0,
@@ -14076,16 +15246,16 @@ export declare const PaymentRequest: Readonly<{
             route: CrossChainRoutePair;
             /**
              * Maximum slippage tolerance in basis points (1/100 of a percent)
-             * for the cross-chain quote. Must be in `10..=500`. Falls back to
-             * [`Config::default_slippage_bps`] when `None`, which itself
-             * defaults to 100 bps (1%) when unset.
+             * for the cross-chain quote. Must be in 10 to 500. Falls back to
+             * [`Config::default_slippage_bps`] when unset, which itself
+             * defaults to 100 bps (1%).
              */ maxSlippageBps: /*u32*/ number | undefined;
             /**
              * Target-overpay pad in basis points applied on `FeesExcluded`
              * conversion sends. Inflates the destination target before quoting
              * so the recipient lands at or above the user's requested amount
-             * despite provider slippage. Must be in `0..=500`. Falls back to
-             * [`CrossChainConfig::default_target_overpay_bps`] when `None`,
+             * despite provider slippage. Must be in 0 to 500. Falls back to
+             * [`CrossChainConfig::default_target_overpay_bps`] when unset,
              * which itself defaults to 15 bps.
              */ targetOverpayBps: /*u32*/ number | undefined;
         }): {
@@ -14107,16 +15277,16 @@ export declare const PaymentRequest: Readonly<{
             route: CrossChainRoutePair;
             /**
              * Maximum slippage tolerance in basis points (1/100 of a percent)
-             * for the cross-chain quote. Must be in `10..=500`. Falls back to
-             * [`Config::default_slippage_bps`] when `None`, which itself
-             * defaults to 100 bps (1%) when unset.
+             * for the cross-chain quote. Must be in 10 to 500. Falls back to
+             * [`Config::default_slippage_bps`] when unset, which itself
+             * defaults to 100 bps (1%).
              */ maxSlippageBps: /*u32*/ number | undefined;
             /**
              * Target-overpay pad in basis points applied on `FeesExcluded`
              * conversion sends. Inflates the destination target before quoting
              * so the recipient lands at or above the user's requested amount
-             * despite provider slippage. Must be in `0..=500`. Falls back to
-             * [`CrossChainConfig::default_target_overpay_bps`] when `None`,
+             * despite provider slippage. Must be in 0 to 500. Falls back to
+             * [`CrossChainConfig::default_target_overpay_bps`] when unset,
              * which itself defaults to 15 bps.
              */ targetOverpayBps: /*u32*/ number | undefined;
         }): {
@@ -15179,7 +16349,8 @@ export declare enum ReceivePaymentMethod_Tags {
     SparkAddress = "SparkAddress",
     SparkInvoice = "SparkInvoice",
     BitcoinAddress = "BitcoinAddress",
-    Bolt11Invoice = "Bolt11Invoice"
+    Bolt11Invoice = "Bolt11Invoice",
+    CrossChain = "CrossChain"
 }
 export declare const ReceivePaymentMethod: Readonly<{
     instanceOf: (obj: any) => obj is ReceivePaymentMethod;
@@ -15414,6 +16585,130 @@ export declare const ReceivePaymentMethod: Readonly<{
             readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
         };
     };
+    CrossChain: {
+        new (inner: {
+            /**
+             * The selected cross-chain route in the receive direction.
+             */ route: CrossChainRoutePair;
+            /**
+             * The amount, in the source asset's base units (`route.decimals`).
+             * USD-stable sources are at parity, so `1 USD = 10^route.decimals`
+             * (e.g. `1_000_000` for 6-decimal USDC/USDT, `10^18` for 18-decimal
+             * BSC USDC).
+             *
+             * - `FeesExcluded` (default): what the receiver ends up with, sized
+             * as if `amount` source units were converted to the Spark-side
+             * destination at parity (USDB) or the live BTC/USD rate (Bitcoin).
+             * - `FeesIncluded`: what the sender deposits. The receiver ends up
+             * with that amount minus provider fees.
+             */ amount: U128;
+            /**
+             * Spark-side asset the receiver wants delivered. When absent, the
+             * SDK auto-selects: the wallet's active stable-balance token if
+             * the route supports it, otherwise Bitcoin (sats). When set, the
+             * value must appear in the route's `accepted_assets`.
+             */ destination: SparkAsset | undefined;
+            /**
+             * How `amount` should be interpreted. When absent, defaults to
+             * `FeesExcluded`.
+             */ feeMode: CrossChainFeeMode | undefined;
+            /**
+             * Maximum slippage in basis points. When absent, the SDK default
+             * (100 bps) is used.
+             */ maxSlippageBps: /*u32*/ number | undefined;
+            /**
+             * Per-request override for the overpay buffer applied to the
+             * sender's deposit when `fee_mode == FeesExcluded`. Range 0 to 500.
+             * When absent, falls back to `CrossChainConfig::default_target_overpay_bps`
+             * then the built-in default (15 bps). Ignored when `fee_mode`
+             * is `FeesIncluded`.
+             */ targetOverpayBps: /*u32*/ number | undefined;
+        }): {
+            readonly tag: ReceivePaymentMethod_Tags.CrossChain;
+            readonly inner: Readonly<{
+                route: CrossChainRoutePair;
+                amount: U128;
+                destination: SparkAsset | undefined;
+                feeMode: CrossChainFeeMode | undefined;
+                maxSlippageBps: /*u32*/ number | undefined;
+                targetOverpayBps: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+        "new"(inner: {
+            /**
+             * The selected cross-chain route in the receive direction.
+             */ route: CrossChainRoutePair;
+            /**
+             * The amount, in the source asset's base units (`route.decimals`).
+             * USD-stable sources are at parity, so `1 USD = 10^route.decimals`
+             * (e.g. `1_000_000` for 6-decimal USDC/USDT, `10^18` for 18-decimal
+             * BSC USDC).
+             *
+             * - `FeesExcluded` (default): what the receiver ends up with, sized
+             * as if `amount` source units were converted to the Spark-side
+             * destination at parity (USDB) or the live BTC/USD rate (Bitcoin).
+             * - `FeesIncluded`: what the sender deposits. The receiver ends up
+             * with that amount minus provider fees.
+             */ amount: U128;
+            /**
+             * Spark-side asset the receiver wants delivered. When absent, the
+             * SDK auto-selects: the wallet's active stable-balance token if
+             * the route supports it, otherwise Bitcoin (sats). When set, the
+             * value must appear in the route's `accepted_assets`.
+             */ destination: SparkAsset | undefined;
+            /**
+             * How `amount` should be interpreted. When absent, defaults to
+             * `FeesExcluded`.
+             */ feeMode: CrossChainFeeMode | undefined;
+            /**
+             * Maximum slippage in basis points. When absent, the SDK default
+             * (100 bps) is used.
+             */ maxSlippageBps: /*u32*/ number | undefined;
+            /**
+             * Per-request override for the overpay buffer applied to the
+             * sender's deposit when `fee_mode == FeesExcluded`. Range 0 to 500.
+             * When absent, falls back to `CrossChainConfig::default_target_overpay_bps`
+             * then the built-in default (15 bps). Ignored when `fee_mode`
+             * is `FeesIncluded`.
+             */ targetOverpayBps: /*u32*/ number | undefined;
+        }): {
+            readonly tag: ReceivePaymentMethod_Tags.CrossChain;
+            readonly inner: Readonly<{
+                route: CrossChainRoutePair;
+                amount: U128;
+                destination: SparkAsset | undefined;
+                feeMode: CrossChainFeeMode | undefined;
+                maxSlippageBps: /*u32*/ number | undefined;
+                targetOverpayBps: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ReceivePaymentMethod_Tags.CrossChain;
+            readonly inner: Readonly<{
+                route: CrossChainRoutePair;
+                amount: U128;
+                destination: SparkAsset | undefined;
+                feeMode: CrossChainFeeMode | undefined;
+                maxSlippageBps: /*u32*/ number | undefined;
+                targetOverpayBps: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+    };
 }>;
 export type ReceivePaymentMethod = InstanceType<(typeof ReceivePaymentMethod)[keyof Omit<typeof ReceivePaymentMethod, 'instanceOf'>]>;
 export declare enum RefundState_Tags {
@@ -15500,6 +16795,8 @@ export declare enum SdkError_Tags {
     InsufficientFunds = "InsufficientFunds",
     InvalidUuid = "InvalidUuid",
     InvalidInput = "InvalidInput",
+    CrossChainAmountOutOfRange = "CrossChainAmountOutOfRange",
+    CrossChainRouteUnavailable = "CrossChainRouteUnavailable",
     NetworkError = "NetworkError",
     StorageError = "StorageError",
     ChainServiceError = "ChainServiceError",
@@ -15512,7 +16809,6 @@ export declare enum SdkError_Tags {
     OptimizationAlreadyRunning = "OptimizationAlreadyRunning",
     OptimizationCancelled = "OptimizationCancelled",
     InsufficientCpfpFunds = "InsufficientCpfpFunds",
-    FundingUtxoConflict = "FundingUtxoConflict",
     Generic = "Generic"
 }
 /**
@@ -15612,16 +16908,166 @@ export declare const SdkError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        "new"(inner: {
-            /**
-             * The token that cannot cover the payment. Unset when the shortfall is
-             * in sats or when no single token can be named.
-             */ tokenIdentifier: string | undefined;
-        }): {
-            readonly tag: SdkError_Tags.InsufficientFunds;
-            readonly inner: Readonly<{
-                tokenIdentifier: string | undefined;
-            }>;
+        "new"(inner: {
+            /**
+             * The token that cannot cover the payment. Unset when the shortfall is
+             * in sats or when no single token can be named.
+             */ tokenIdentifier: string | undefined;
+        }): {
+            readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            tokenIdentifier: string | undefined;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    InvalidUuid: {
+        new (v0: string): {
+            readonly tag: SdkError_Tags.InvalidUuid;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: SdkError_Tags.InvalidUuid;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.InvalidUuid;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.InvalidUuid;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.InvalidUuid;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    InvalidInput: {
+        new (v0: string): {
+            readonly tag: SdkError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: SdkError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15633,10 +17079,8 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: SdkError_Tags.InsufficientFunds;
-            readonly inner: Readonly<{
-                tokenIdentifier: string | undefined;
-            }>;
+            readonly tag: SdkError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15648,10 +17092,8 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: SdkError_Tags.InsufficientFunds;
-            readonly inner: Readonly<{
-                tokenIdentifier: string | undefined;
-            }>;
+            readonly tag: SdkError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15663,10 +17105,8 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         getInner(obj: {
-            readonly tag: SdkError_Tags.InsufficientFunds;
-            readonly inner: Readonly<{
-                tokenIdentifier: string | undefined;
-            }>;
+            readonly tag: SdkError_Tags.InvalidInput;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15676,18 +17116,34 @@ export declare const SdkError: Readonly<{
             message: string;
             stack?: string;
             cause?: unknown;
-        }): Readonly<{
-            tokenIdentifier: string | undefined;
-        }>;
+        }): Readonly<[string]>;
         isError(error: unknown): error is Error;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
         stackTraceLimit: number;
     };
-    InvalidUuid: {
-        new (v0: string): {
-            readonly tag: SdkError_Tags.InvalidUuid;
-            readonly inner: Readonly<[string]>;
+    CrossChainAmountOutOfRange: {
+        new (inner: {
+            reason: string;
+            /**
+             * `true` for a rejection below the minimum, `false` for one above the
+             * maximum or beyond available liquidity.
+             */ tooSmall: boolean;
+            /**
+             * The published bound in the base units of the asset paid in: the
+             * Spark-side asset on a send, the external asset on a receive.
+             */ boundAmount: U128 | undefined;
+            /**
+             * The published bound as an order value in USD cents.
+             */ boundUsdCents: /*u64*/ bigint | undefined;
+        }): {
+            readonly tag: SdkError_Tags.CrossChainAmountOutOfRange;
+            readonly inner: Readonly<{
+                reason: string;
+                tooSmall: boolean;
+                boundAmount: U128 | undefined;
+                boundUsdCents: /*u64*/ bigint | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15698,9 +17154,27 @@ export declare const SdkError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        "new"(v0: string): {
-            readonly tag: SdkError_Tags.InvalidUuid;
-            readonly inner: Readonly<[string]>;
+        "new"(inner: {
+            reason: string;
+            /**
+             * `true` for a rejection below the minimum, `false` for one above the
+             * maximum or beyond available liquidity.
+             */ tooSmall: boolean;
+            /**
+             * The published bound in the base units of the asset paid in: the
+             * Spark-side asset on a send, the external asset on a receive.
+             */ boundAmount: U128 | undefined;
+            /**
+             * The published bound as an order value in USD cents.
+             */ boundUsdCents: /*u64*/ bigint | undefined;
+        }): {
+            readonly tag: SdkError_Tags.CrossChainAmountOutOfRange;
+            readonly inner: Readonly<{
+                reason: string;
+                tooSmall: boolean;
+                boundAmount: U128 | undefined;
+                boundUsdCents: /*u64*/ bigint | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15712,8 +17186,13 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: SdkError_Tags.InvalidUuid;
-            readonly inner: Readonly<[string]>;
+            readonly tag: SdkError_Tags.CrossChainAmountOutOfRange;
+            readonly inner: Readonly<{
+                reason: string;
+                tooSmall: boolean;
+                boundAmount: U128 | undefined;
+                boundUsdCents: /*u64*/ bigint | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15725,8 +17204,13 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: SdkError_Tags.InvalidUuid;
-            readonly inner: Readonly<[string]>;
+            readonly tag: SdkError_Tags.CrossChainAmountOutOfRange;
+            readonly inner: Readonly<{
+                reason: string;
+                tooSmall: boolean;
+                boundAmount: U128 | undefined;
+                boundUsdCents: /*u64*/ bigint | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15738,8 +17222,13 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         getInner(obj: {
-            readonly tag: SdkError_Tags.InvalidUuid;
-            readonly inner: Readonly<[string]>;
+            readonly tag: SdkError_Tags.CrossChainAmountOutOfRange;
+            readonly inner: Readonly<{
+                reason: string;
+                tooSmall: boolean;
+                boundAmount: U128 | undefined;
+                boundUsdCents: /*u64*/ bigint | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15749,16 +17238,30 @@ export declare const SdkError: Readonly<{
             message: string;
             stack?: string;
             cause?: unknown;
-        }): Readonly<[string]>;
+        }): Readonly<{
+            reason: string;
+            tooSmall: boolean;
+            boundAmount: U128 | undefined;
+            boundUsdCents: /*u64*/ bigint | undefined;
+        }>;
         isError(error: unknown): error is Error;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
         stackTraceLimit: number;
     };
-    InvalidInput: {
-        new (v0: string): {
-            readonly tag: SdkError_Tags.InvalidInput;
-            readonly inner: Readonly<[string]>;
+    CrossChainRouteUnavailable: {
+        new (inner: {
+            reason: string;
+            /**
+             * `true` when the provider expects the route back shortly, so the
+             * same request can succeed later. Otherwise try another route.
+             */ temporary: boolean;
+        }): {
+            readonly tag: SdkError_Tags.CrossChainRouteUnavailable;
+            readonly inner: Readonly<{
+                reason: string;
+                temporary: boolean;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15769,9 +17272,18 @@ export declare const SdkError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        "new"(v0: string): {
-            readonly tag: SdkError_Tags.InvalidInput;
-            readonly inner: Readonly<[string]>;
+        "new"(inner: {
+            reason: string;
+            /**
+             * `true` when the provider expects the route back shortly, so the
+             * same request can succeed later. Otherwise try another route.
+             */ temporary: boolean;
+        }): {
+            readonly tag: SdkError_Tags.CrossChainRouteUnavailable;
+            readonly inner: Readonly<{
+                reason: string;
+                temporary: boolean;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15783,8 +17295,11 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: SdkError_Tags.InvalidInput;
-            readonly inner: Readonly<[string]>;
+            readonly tag: SdkError_Tags.CrossChainRouteUnavailable;
+            readonly inner: Readonly<{
+                reason: string;
+                temporary: boolean;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15796,8 +17311,11 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: SdkError_Tags.InvalidInput;
-            readonly inner: Readonly<[string]>;
+            readonly tag: SdkError_Tags.CrossChainRouteUnavailable;
+            readonly inner: Readonly<{
+                reason: string;
+                temporary: boolean;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15809,8 +17327,11 @@ export declare const SdkError: Readonly<{
             cause?: unknown;
         };
         getInner(obj: {
-            readonly tag: SdkError_Tags.InvalidInput;
-            readonly inner: Readonly<[string]>;
+            readonly tag: SdkError_Tags.CrossChainRouteUnavailable;
+            readonly inner: Readonly<{
+                reason: string;
+                temporary: boolean;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -15820,7 +17341,10 @@ export declare const SdkError: Readonly<{
             message: string;
             stack?: string;
             cause?: unknown;
-        }): Readonly<[string]>;
+        }): Readonly<{
+            reason: string;
+            temporary: boolean;
+        }>;
         isError(error: unknown): error is Error;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -16780,101 +18304,6 @@ export declare const SdkError: Readonly<{
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
         stackTraceLimit: number;
     };
-    FundingUtxoConflict: {
-        new (inner: {
-            txid: string;
-            vout: number;
-        }): {
-            readonly tag: SdkError_Tags.FundingUtxoConflict;
-            readonly inner: Readonly<{
-                txid: string;
-                vout: number;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "SdkError";
-            name: string;
-            message: string;
-            stack?: string;
-            cause?: unknown;
-        };
-        "new"(inner: {
-            txid: string;
-            vout: number;
-        }): {
-            readonly tag: SdkError_Tags.FundingUtxoConflict;
-            readonly inner: Readonly<{
-                txid: string;
-                vout: number;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "SdkError";
-            name: string;
-            message: string;
-            stack?: string;
-            cause?: unknown;
-        };
-        instanceOf(obj: any): obj is {
-            readonly tag: SdkError_Tags.FundingUtxoConflict;
-            readonly inner: Readonly<{
-                txid: string;
-                vout: number;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "SdkError";
-            name: string;
-            message: string;
-            stack?: string;
-            cause?: unknown;
-        };
-        hasInner(obj: any): obj is {
-            readonly tag: SdkError_Tags.FundingUtxoConflict;
-            readonly inner: Readonly<{
-                txid: string;
-                vout: number;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "SdkError";
-            name: string;
-            message: string;
-            stack?: string;
-            cause?: unknown;
-        };
-        getInner(obj: {
-            readonly tag: SdkError_Tags.FundingUtxoConflict;
-            readonly inner: Readonly<{
-                txid: string;
-                vout: number;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "SdkError";
-            name: string;
-            message: string;
-            stack?: string;
-            cause?: unknown;
-        }): Readonly<{
-            txid: string;
-            vout: number;
-        }>;
-        isError(error: unknown): error is Error;
-        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-        stackTraceLimit: number;
-    };
     Generic: {
         new (v0: string): {
             readonly tag: SdkError_Tags.Generic;
@@ -16958,6 +18387,7 @@ export declare enum SdkEvent_Tags {
     PaymentSucceeded = "PaymentSucceeded",
     PaymentPending = "PaymentPending",
     PaymentFailed = "PaymentFailed",
+    PaymentMetadataUpdated = "PaymentMetadataUpdated",
     AutoOptimization = "AutoOptimization",
     LightningAddressChanged = "LightningAddressChanged",
     NewDeposits = "NewDeposits",
@@ -17063,7 +18493,46 @@ export declare const SdkEvent: Readonly<{
         instanceOf(obj: any): obj is {
             readonly tag: SdkEvent_Tags.ClaimedDeposits;
             readonly inner: Readonly<{
-                claimedDeposits: Array<DepositInfo>;
+                claimedDeposits: Array<DepositInfo>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkEvent";
+        };
+    };
+    PaymentSucceeded: {
+        new (inner: {
+            payment: Payment;
+        }): {
+            readonly tag: SdkEvent_Tags.PaymentSucceeded;
+            readonly inner: Readonly<{
+                payment: Payment;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkEvent";
+        };
+        "new"(inner: {
+            payment: Payment;
+        }): {
+            readonly tag: SdkEvent_Tags.PaymentSucceeded;
+            readonly inner: Readonly<{
+                payment: Payment;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkEvent";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkEvent_Tags.PaymentSucceeded;
+            readonly inner: Readonly<{
+                payment: Payment;
             }>;
             /**
              * @private
@@ -17072,11 +18541,11 @@ export declare const SdkEvent: Readonly<{
             readonly [uniffiTypeNameSymbol]: "SdkEvent";
         };
     };
-    PaymentSucceeded: {
+    PaymentPending: {
         new (inner: {
             payment: Payment;
         }): {
-            readonly tag: SdkEvent_Tags.PaymentSucceeded;
+            readonly tag: SdkEvent_Tags.PaymentPending;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17089,7 +18558,7 @@ export declare const SdkEvent: Readonly<{
         "new"(inner: {
             payment: Payment;
         }): {
-            readonly tag: SdkEvent_Tags.PaymentSucceeded;
+            readonly tag: SdkEvent_Tags.PaymentPending;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17100,7 +18569,7 @@ export declare const SdkEvent: Readonly<{
             readonly [uniffiTypeNameSymbol]: "SdkEvent";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: SdkEvent_Tags.PaymentSucceeded;
+            readonly tag: SdkEvent_Tags.PaymentPending;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17111,11 +18580,11 @@ export declare const SdkEvent: Readonly<{
             readonly [uniffiTypeNameSymbol]: "SdkEvent";
         };
     };
-    PaymentPending: {
+    PaymentFailed: {
         new (inner: {
             payment: Payment;
         }): {
-            readonly tag: SdkEvent_Tags.PaymentPending;
+            readonly tag: SdkEvent_Tags.PaymentFailed;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17128,7 +18597,7 @@ export declare const SdkEvent: Readonly<{
         "new"(inner: {
             payment: Payment;
         }): {
-            readonly tag: SdkEvent_Tags.PaymentPending;
+            readonly tag: SdkEvent_Tags.PaymentFailed;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17139,7 +18608,7 @@ export declare const SdkEvent: Readonly<{
             readonly [uniffiTypeNameSymbol]: "SdkEvent";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: SdkEvent_Tags.PaymentPending;
+            readonly tag: SdkEvent_Tags.PaymentFailed;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17150,11 +18619,11 @@ export declare const SdkEvent: Readonly<{
             readonly [uniffiTypeNameSymbol]: "SdkEvent";
         };
     };
-    PaymentFailed: {
+    PaymentMetadataUpdated: {
         new (inner: {
             payment: Payment;
         }): {
-            readonly tag: SdkEvent_Tags.PaymentFailed;
+            readonly tag: SdkEvent_Tags.PaymentMetadataUpdated;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17167,7 +18636,7 @@ export declare const SdkEvent: Readonly<{
         "new"(inner: {
             payment: Payment;
         }): {
-            readonly tag: SdkEvent_Tags.PaymentFailed;
+            readonly tag: SdkEvent_Tags.PaymentMetadataUpdated;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17178,7 +18647,7 @@ export declare const SdkEvent: Readonly<{
             readonly [uniffiTypeNameSymbol]: "SdkEvent";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: SdkEvent_Tags.PaymentFailed;
+            readonly tag: SdkEvent_Tags.PaymentMetadataUpdated;
             readonly inner: Readonly<{
                 payment: Payment;
             }>;
@@ -17693,6 +19162,10 @@ export declare const SendPaymentMethod: Readonly<{
             /**
              * Asset which service fee is denominated in. Unset means BTC sats.
              */ serviceFeeAsset: string | undefined;
+            /**
+             * Decimals of `service_fee_asset`, for formatting `service_fee_amount`.
+             * Unset when the fee is in sats or the provider did not report them.
+             */ serviceFeeAssetDecimals: /*u32*/ number | undefined;
             /**
              * Sats budget for moving the amount in from the wallet to the provider.
              */ sourceTransferFeeSats: bigint;
@@ -17717,6 +19190,7 @@ export declare const SendPaymentMethod: Readonly<{
                 feeAmount: U128;
                 serviceFeeAmount: U128;
                 serviceFeeAsset: string | undefined;
+                serviceFeeAssetDecimals: /*u32*/ number | undefined;
                 sourceTransferFeeSats: bigint;
                 feeMode: CrossChainFeeMode;
                 expiresAt: string;
@@ -17762,6 +19236,10 @@ export declare const SendPaymentMethod: Readonly<{
             /**
              * Asset which service fee is denominated in. Unset means BTC sats.
              */ serviceFeeAsset: string | undefined;
+            /**
+             * Decimals of `service_fee_asset`, for formatting `service_fee_amount`.
+             * Unset when the fee is in sats or the provider did not report them.
+             */ serviceFeeAssetDecimals: /*u32*/ number | undefined;
             /**
              * Sats budget for moving the amount in from the wallet to the provider.
              */ sourceTransferFeeSats: bigint;
@@ -17786,6 +19264,7 @@ export declare const SendPaymentMethod: Readonly<{
                 feeAmount: U128;
                 serviceFeeAmount: U128;
                 serviceFeeAsset: string | undefined;
+                serviceFeeAssetDecimals: /*u32*/ number | undefined;
                 sourceTransferFeeSats: bigint;
                 feeMode: CrossChainFeeMode;
                 expiresAt: string;
@@ -17808,6 +19287,7 @@ export declare const SendPaymentMethod: Readonly<{
                 feeAmount: U128;
                 serviceFeeAmount: U128;
                 serviceFeeAsset: string | undefined;
+                serviceFeeAssetDecimals: /*u32*/ number | undefined;
                 sourceTransferFeeSats: bigint;
                 feeMode: CrossChainFeeMode;
                 expiresAt: string;
@@ -19465,46 +20945,46 @@ export declare const SignerError: Readonly<{
  * Error type for signer operations
  */
 export type SignerError = InstanceType<(typeof SignerError)[keyof Omit<typeof SignerError, 'instanceOf'>]>;
-export declare enum SourceAsset_Tags {
+export declare enum SparkAsset_Tags {
     Bitcoin = "Bitcoin",
     Token = "Token"
 }
 /**
- * The source asset a cross-chain route accepts as input on the Spark side.
+ * The asset a cross-chain route accepts on the Spark side.
  */
-export declare const SourceAsset: Readonly<{
-    instanceOf: (obj: any) => obj is SourceAsset;
+export declare const SparkAsset: Readonly<{
+    instanceOf: (obj: any) => obj is SparkAsset;
     Bitcoin: {
         new (): {
-            readonly tag: SourceAsset_Tags.Bitcoin;
+            readonly tag: SparkAsset_Tags.Bitcoin;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SourceAsset";
+            readonly [uniffiTypeNameSymbol]: "SparkAsset";
         };
         "new"(): {
-            readonly tag: SourceAsset_Tags.Bitcoin;
+            readonly tag: SparkAsset_Tags.Bitcoin;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SourceAsset";
+            readonly [uniffiTypeNameSymbol]: "SparkAsset";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: SourceAsset_Tags.Bitcoin;
+            readonly tag: SparkAsset_Tags.Bitcoin;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SourceAsset";
+            readonly [uniffiTypeNameSymbol]: "SparkAsset";
         };
     };
     Token: {
         new (inner: {
             tokenIdentifier: string;
         }): {
-            readonly tag: SourceAsset_Tags.Token;
+            readonly tag: SparkAsset_Tags.Token;
             readonly inner: Readonly<{
                 tokenIdentifier: string;
             }>;
@@ -19512,12 +20992,12 @@ export declare const SourceAsset: Readonly<{
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SourceAsset";
+            readonly [uniffiTypeNameSymbol]: "SparkAsset";
         };
         "new"(inner: {
             tokenIdentifier: string;
         }): {
-            readonly tag: SourceAsset_Tags.Token;
+            readonly tag: SparkAsset_Tags.Token;
             readonly inner: Readonly<{
                 tokenIdentifier: string;
             }>;
@@ -19525,10 +21005,10 @@ export declare const SourceAsset: Readonly<{
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SourceAsset";
+            readonly [uniffiTypeNameSymbol]: "SparkAsset";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: SourceAsset_Tags.Token;
+            readonly tag: SparkAsset_Tags.Token;
             readonly inner: Readonly<{
                 tokenIdentifier: string;
             }>;
@@ -19536,32 +21016,14 @@ export declare const SourceAsset: Readonly<{
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SourceAsset";
+            readonly [uniffiTypeNameSymbol]: "SparkAsset";
         };
     };
 }>;
 /**
- * The source asset a cross-chain route accepts as input on the Spark side.
+ * The asset a cross-chain route accepts on the Spark side.
  */
-export type SourceAsset = InstanceType<(typeof SourceAsset)[keyof Omit<typeof SourceAsset, 'instanceOf'>]>;
-/**
- * The chain a cross-chain route is funded from, orthogonal to the
- * [`SourceAsset`] that moves.
- */
-export declare enum SourceChain {
-    /**
-     * Paid over Spark, using a Bitcoin or token source asset.
-     */
-    Spark = 0,
-    /**
-     * Paid over Lightning, using a Bitcoin source asset.
-     */
-    Lightning = 1,
-    /**
-     * Paid on-chain to Bitcoin (L1), using a Bitcoin source asset.
-     */
-    Bitcoin = 2
-}
+export type SparkAsset = InstanceType<(typeof SparkAsset)[keyof Omit<typeof SparkAsset, 'instanceOf'>]>;
 export declare enum SparkHtlcStatus {
     /**
      * The HTLC is waiting for the preimage to be shared by the receiver
@@ -20783,6 +22245,18 @@ export declare const TransferTarget: Readonly<{
     };
 }>;
 export type TransferTarget = InstanceType<(typeof TransferTarget)[keyof Omit<typeof TransferTarget, 'instanceOf'>]>;
+/**
+ * Why an exit has to be built again.
+ */
+export declare enum UnilateralExitRedoReason {
+    /**
+     * The chain no longer matches the exit: something that is not one of its
+     * own transactions took an outpoint it still needs. A different refund, a
+     * fee bump from elsewhere, or funding spent on something else all land
+     * here.
+     */
+    OnChainStateDiverged = 0
+}
 /**
  * The role of a transaction in the exit path.
  */
@@ -20805,6 +22279,112 @@ export declare enum UnilateralExitTxKind {
      */
     Sweep = 3
 }
+export declare enum UnilateralExitVerdict_Tags {
+    Valid = "Valid",
+    Done = "Done",
+    Redo = "Redo"
+}
+/**
+ * What to do with an exit that has been read back against the chain.
+ */
+export declare const UnilateralExitVerdict: Readonly<{
+    instanceOf: (obj: any) => obj is UnilateralExitVerdict;
+    Valid: {
+        new (): {
+            readonly tag: UnilateralExitVerdict_Tags.Valid;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+        "new"(): {
+            readonly tag: UnilateralExitVerdict_Tags.Valid;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: UnilateralExitVerdict_Tags.Valid;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+    };
+    Done: {
+        new (): {
+            readonly tag: UnilateralExitVerdict_Tags.Done;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+        "new"(): {
+            readonly tag: UnilateralExitVerdict_Tags.Done;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: UnilateralExitVerdict_Tags.Done;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+    };
+    Redo: {
+        new (inner: {
+            reason: UnilateralExitRedoReason;
+        }): {
+            readonly tag: UnilateralExitVerdict_Tags.Redo;
+            readonly inner: Readonly<{
+                reason: UnilateralExitRedoReason;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+        "new"(inner: {
+            reason: UnilateralExitRedoReason;
+        }): {
+            readonly tag: UnilateralExitVerdict_Tags.Redo;
+            readonly inner: Readonly<{
+                reason: UnilateralExitRedoReason;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: UnilateralExitVerdict_Tags.Redo;
+            readonly inner: Readonly<{
+                reason: UnilateralExitRedoReason;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnilateralExitVerdict";
+        };
+    };
+}>;
+/**
+ * What to do with an exit that has been read back against the chain.
+ */
+export type UnilateralExitVerdict = InstanceType<(typeof UnilateralExitVerdict)[keyof Omit<typeof UnilateralExitVerdict, 'instanceOf'>]>;
 export declare enum UnsignedTransferPackage_Tags {
     Swap = "Swap",
     Transfer = "Transfer",
@@ -21067,7 +22647,8 @@ export declare enum UpdateDepositPayload_Tags {
     ClaimError = "ClaimError",
     Refund = "Refund",
     InstantClaim = "InstantClaim",
-    RefundBroadcastState = "RefundBroadcastState"
+    RefundBroadcastState = "RefundBroadcastState",
+    MaxClaimFee = "MaxClaimFee"
 }
 export declare const UpdateDepositPayload: Readonly<{
     instanceOf: (obj: any) => obj is UpdateDepositPayload;
@@ -21242,8 +22823,160 @@ export declare const UpdateDepositPayload: Readonly<{
             readonly [uniffiTypeNameSymbol]: "UpdateDepositPayload";
         };
     };
+    MaxClaimFee: {
+        new (inner: {
+            maxFee: MaxFee | undefined;
+        }): {
+            readonly tag: UpdateDepositPayload_Tags.MaxClaimFee;
+            readonly inner: Readonly<{
+                maxFee: MaxFee | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateDepositPayload";
+        };
+        "new"(inner: {
+            maxFee: MaxFee | undefined;
+        }): {
+            readonly tag: UpdateDepositPayload_Tags.MaxClaimFee;
+            readonly inner: Readonly<{
+                maxFee: MaxFee | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateDepositPayload";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: UpdateDepositPayload_Tags.MaxClaimFee;
+            readonly inner: Readonly<{
+                maxFee: MaxFee | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateDepositPayload";
+        };
+    };
 }>;
 export type UpdateDepositPayload = InstanceType<(typeof UpdateDepositPayload)[keyof Omit<typeof UpdateDepositPayload, 'instanceOf'>]>;
+export declare enum UpdateWatchedAddressPayload_Tags {
+    Watch = "Watch",
+    Seen = "Seen",
+    Unwatch = "Unwatch"
+}
+export declare const UpdateWatchedAddressPayload: Readonly<{
+    instanceOf: (obj: any) => obj is UpdateWatchedAddressPayload;
+    Watch: {
+        new (inner: {
+            issuedAt: bigint;
+        }): {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Watch;
+            readonly inner: Readonly<{
+                issuedAt: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+        "new"(inner: {
+            issuedAt: bigint;
+        }): {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Watch;
+            readonly inner: Readonly<{
+                issuedAt: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Watch;
+            readonly inner: Readonly<{
+                issuedAt: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+    };
+    Seen: {
+        new (): {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Seen;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+        "new"(): {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Seen;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Seen;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+    };
+    Unwatch: {
+        new (inner: {
+            issuedAt: bigint;
+        }): {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Unwatch;
+            readonly inner: Readonly<{
+                issuedAt: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+        "new"(inner: {
+            issuedAt: bigint;
+        }): {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Unwatch;
+            readonly inner: Readonly<{
+                issuedAt: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: UpdateWatchedAddressPayload_Tags.Unwatch;
+            readonly inner: Readonly<{
+                issuedAt: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UpdateWatchedAddressPayload";
+        };
+    };
+}>;
+export type UpdateWatchedAddressPayload = InstanceType<(typeof UpdateWatchedAddressPayload)[keyof Omit<typeof UpdateWatchedAddressPayload, 'instanceOf'>]>;
 export declare enum WebhookEventType_Tags {
     LightningReceiveFinished = "LightningReceiveFinished",
     LightningSendFinished = "LightningSendFinished",
@@ -21571,6 +23304,17 @@ export interface BreezSdkInterface {
     checkMessage(request: CheckMessageRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<CheckMessageResponse>;
+    /**
+     * Reads an exit you kept back against the chain: which of its transactions
+     * are now in a block, and whether it can still be finished as it stands.
+     *
+     * Needs neither the wallet's leaves nor a signer, so an exit can be followed
+     * from the response alone. Store the response in place of the one you passed
+     * in, and broadcast what its statuses leave to send.
+     */
+    checkUnilateralExit(request: CheckUnilateralExitRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CheckUnilateralExitResponse>;
     claimDeposit(request: ClaimDepositRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ClaimDepositResponse>;
@@ -21984,7 +23728,13 @@ export interface BreezSdkInterface {
         signal: AbortSignal;
     }): Promise<SignMessageResponse>;
     /**
-     * Synchronizes the wallet with the Spark network
+     * Synchronizes the wallet with the Spark network.
+     *
+     * Also collects the data a unilateral exit needs for any leaf still missing
+     * it, and waits for that before returning. This happens regardless of
+     * [`exit_chain_auto_fetch_enabled`](crate::Config::exit_chain_auto_fetch_enabled),
+     * which governs only the automatic collection: syncing is how to run one at
+     * a moment of your choosing with that turned off.
      */
     syncWallet(request: SyncWalletRequest, asyncOpts_?: {
         signal: AbortSignal;
@@ -21995,11 +23745,10 @@ export interface BreezSdkInterface {
      * topological broadcast order without broadcasting. Broadcast it over time,
      * respecting each transaction's `depends_on` and `csv_timelock_blocks`.
      *
-     * It resolves on-chain state first (see [`resolve_exit_observations`]): an
-     * already-confirmed fan-out or CPFP node is not rebuilt, and a leaf refund
-     * already on-chain (recognized by the leaf's refund address, so any refund
-     * variant counts) is swept directly. Re-running after partial progress
-     * therefore resumes rather than restarts.
+     * It reads on-chain state first: an already-confirmed fan-out or CPFP node
+     * is not rebuilt, and a leaf refund already on-chain (recognized by the
+     * leaf's refund address, so any refund variant counts) is swept directly.
+     * Re-running after partial progress therefore resumes rather than restarts.
      */
     unilateralExit(request: UnilateralExitRequest, signer: CpfpSigner, asyncOpts_?: {
         signal: AbortSignal;
@@ -22138,6 +23887,17 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
     checkMessage(request: CheckMessageRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<CheckMessageResponse>;
+    /**
+     * Reads an exit you kept back against the chain: which of its transactions
+     * are now in a block, and whether it can still be finished as it stands.
+     *
+     * Needs neither the wallet's leaves nor a signer, so an exit can be followed
+     * from the response alone. Store the response in place of the one you passed
+     * in, and broadcast what its statuses leave to send.
+     */
+    checkUnilateralExit(request: CheckUnilateralExitRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<CheckUnilateralExitResponse>;
     claimDeposit(request: ClaimDepositRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ClaimDepositResponse>;
@@ -22551,7 +24311,13 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
         signal: AbortSignal;
     }): Promise<SignMessageResponse>;
     /**
-     * Synchronizes the wallet with the Spark network
+     * Synchronizes the wallet with the Spark network.
+     *
+     * Also collects the data a unilateral exit needs for any leaf still missing
+     * it, and waits for that before returning. This happens regardless of
+     * [`exit_chain_auto_fetch_enabled`](crate::Config::exit_chain_auto_fetch_enabled),
+     * which governs only the automatic collection: syncing is how to run one at
+     * a moment of your choosing with that turned off.
      */
     syncWallet(request: SyncWalletRequest, asyncOpts_?: {
         signal: AbortSignal;
@@ -22562,11 +24328,10 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
      * topological broadcast order without broadcasting. Broadcast it over time,
      * respecting each transaction's `depends_on` and `csv_timelock_blocks`.
      *
-     * It resolves on-chain state first (see [`resolve_exit_observations`]): an
-     * already-confirmed fan-out or CPFP node is not rebuilt, and a leaf refund
-     * already on-chain (recognized by the leaf's refund address, so any refund
-     * variant counts) is swept directly. Re-running after partial progress
-     * therefore resumes rather than restarts.
+     * It reads on-chain state first: an already-confirmed fan-out or CPFP node
+     * is not rebuilt, and a leaf refund already on-chain (recognized by the
+     * leaf's refund address, so any refund variant counts) is swept directly.
+     * Re-running after partial progress therefore resumes rather than restarts.
      */
     unilateralExit(request: UnilateralExitRequest, signer: CpfpSigner, asyncOpts_?: {
         signal: AbortSignal;
@@ -23038,7 +24803,7 @@ export interface ExternalSparkSigner {
         signal: AbortSignal;
     }): Promise<PublicKeyBytes>;
     /**
-     * The signing public key for a tree leaf.
+     * The public key of the leaf signing key derived from `leaf_id`.
      */
     getPublicKeyForLeaf(leafId: ExternalTreeNodeId, asyncOpts_?: {
         signal: AbortSignal;
@@ -23070,7 +24835,8 @@ export interface ExternalSparkSigner {
     }): Promise<EcdsaSignatureBytes>;
     /**
      * Schnorr-sign `sighash` to spend a tree leaf's P2TR refund output as a
-     * BIP341 key-path spend (empty script tree).
+     * BIP341 key-path spend (empty script tree), with the leaf signing key
+     * derived from `leaf_id`.
      */
     signLeafRefundSpend(leafId: ExternalTreeNodeId, sighash: ArrayBuffer, asyncOpts_?: {
         signal: AbortSignal;
@@ -23151,7 +24917,7 @@ export declare class ExternalSparkSignerImpl extends UniffiAbstractObject implem
         signal: AbortSignal;
     }): Promise<PublicKeyBytes>;
     /**
-     * The signing public key for a tree leaf.
+     * The public key of the leaf signing key derived from `leaf_id`.
      */
     getPublicKeyForLeaf(leafId: ExternalTreeNodeId, asyncOpts_?: {
         signal: AbortSignal;
@@ -23183,7 +24949,8 @@ export declare class ExternalSparkSignerImpl extends UniffiAbstractObject implem
     }): Promise<EcdsaSignatureBytes>;
     /**
      * Schnorr-sign `sighash` to spend a tree leaf's P2TR refund output as a
-     * BIP341 key-path spend (empty script tree).
+     * BIP341 key-path spend (empty script tree), with the leaf signing key
+     * derived from `leaf_id`.
      */
     signLeafRefundSpend(leafId: ExternalTreeNodeId, sighash: ArrayBuffer, asyncOpts_?: {
         signal: AbortSignal;
@@ -23852,7 +25619,7 @@ export interface SdkBuilderInterface {
      * Sets the account number for key derivation. All wallet keys derive from
      * the seed at `m/8797555'/<account number>'`, so each account number
      * yields an independent wallet from the same seed. Defaults to 0 on
-     * Regtest and 1 on all other networks when unset.
+     * Regtest and Signet, and 1 on Mainnet when unset.
      * Arguments:
      * - `account_number`: The account number in the derivation path.
      */
@@ -24003,7 +25770,7 @@ export declare class SdkBuilder extends UniffiAbstractObject implements SdkBuild
      * Sets the account number for key derivation. All wallet keys derive from
      * the seed at `m/8797555'/<account number>'`, so each account number
      * yields an independent wallet from the same seed. Defaults to 0 on
-     * Regtest and 1 on all other networks when unset.
+     * Regtest and Signet, and 1 on Mainnet when unset.
      * Arguments:
      * - `account_number`: The account number in the derivation path.
      */
@@ -24345,6 +26112,20 @@ export interface Storage {
     updateDeposit(txid: string, vout: number, payload: UpdateDepositPayload, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
+    /**
+     * Lists the deposit addresses currently being watched for unconfirmed
+     * deposits, most recently issued first.
+     */
+    listWatchedDepositAddresses(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<WatchedDepositAddress>>;
+    /**
+     * Applies one change to a watched deposit address. `Watch` inserts or
+     * restarts it, `Seen` marks it, and `Unwatch` removes it.
+     */
+    updateWatchedDepositAddress(address: string, payload: UpdateWatchedAddressPayload, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     setLnurlMetadata(metadata: Array<SetLnurlMetadataItem>, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
@@ -24596,6 +26377,20 @@ export declare class StorageImpl extends UniffiAbstractObject implements Storage
     updateDeposit(txid: string, vout: number, payload: UpdateDepositPayload, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
+    /**
+     * Lists the deposit addresses currently being watched for unconfirmed
+     * deposits, most recently issued first.
+     */
+    listWatchedDepositAddresses(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<WatchedDepositAddress>>;
+    /**
+     * Applies one change to a watched deposit address. `Watch` inserts or
+     * restarts it, `Seen` marks it, and `Unwatch` removes it.
+     */
+    updateWatchedDepositAddress(address: string, payload: UpdateWatchedAddressPayload, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     setLnurlMetadata(metadata: Array<SetLnurlMetadataItem>, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
@@ -25237,6 +27032,34 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): CheckMessageResponse;
             lower(value: CheckMessageResponse): UniffiByteArray;
         };
+        FfiConverterTypeCheckUnilateralExitRequest: {
+            read(from: RustBuffer): CheckUnilateralExitRequest;
+            write(value: CheckUnilateralExitRequest, into: RustBuffer): void;
+            allocationSize(value: CheckUnilateralExitRequest): number;
+            lift(value: UniffiByteArray): CheckUnilateralExitRequest;
+            lower(value: CheckUnilateralExitRequest): UniffiByteArray;
+        };
+        FfiConverterTypeCheckUnilateralExitResponse: {
+            read(from: RustBuffer): CheckUnilateralExitResponse;
+            write(value: CheckUnilateralExitResponse, into: RustBuffer): void;
+            allocationSize(value: CheckUnilateralExitResponse): number;
+            lift(value: UniffiByteArray): CheckUnilateralExitResponse;
+            lower(value: CheckUnilateralExitResponse): UniffiByteArray;
+        };
+        FfiConverterTypeClaimDeferredReason: {
+            read(from: RustBuffer): ClaimDeferredReason;
+            write(value: ClaimDeferredReason, into: RustBuffer): void;
+            allocationSize(value: ClaimDeferredReason): number;
+            lift(value: UniffiByteArray): ClaimDeferredReason;
+            lower(value: ClaimDeferredReason): UniffiByteArray;
+        };
+        FfiConverterTypeClaimDepositOutcome: {
+            read(from: RustBuffer): ClaimDepositOutcome;
+            write(value: ClaimDepositOutcome, into: RustBuffer): void;
+            allocationSize(value: ClaimDepositOutcome): number;
+            lift(value: UniffiByteArray): ClaimDepositOutcome;
+            lower(value: ClaimDepositOutcome): UniffiByteArray;
+        };
         FfiConverterTypeClaimDepositQuote: {
             read(from: RustBuffer): ClaimDepositQuote;
             write(value: ClaimDepositQuote, into: RustBuffer): void;
@@ -25286,12 +27109,12 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): Config;
             lower(value: Config): UniffiByteArray;
         };
-        FfiConverterTypeConfirmationStatus: {
-            read(from: RustBuffer): ConfirmationStatus;
-            write(value: ConfirmationStatus, into: RustBuffer): void;
-            allocationSize(value: ConfirmationStatus): number;
-            lift(value: UniffiByteArray): ConfirmationStatus;
-            lower(value: ConfirmationStatus): UniffiByteArray;
+        FfiConverterTypeConfirmedExitNode: {
+            read(from: RustBuffer): ConfirmedExitNode;
+            write(value: ConfirmedExitNode, into: RustBuffer): void;
+            allocationSize(value: ConfirmedExitNode): number;
+            lift(value: UniffiByteArray): ConfirmedExitNode;
+            lower(value: ConfirmedExitNode): UniffiByteArray;
         };
         FfiConverterTypeConnectRequest: {
             read(from: RustBuffer): ConnectRequest;
@@ -25462,6 +27285,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): Credentials;
             lower(value: Credentials): UniffiByteArray;
         };
+        FfiConverterTypeCrossChainAcceptedAsset: {
+            read(from: RustBuffer): CrossChainAcceptedAsset;
+            write(value: CrossChainAcceptedAsset, into: RustBuffer): void;
+            allocationSize(value: CrossChainAcceptedAsset): number;
+            lift(value: UniffiByteArray): CrossChainAcceptedAsset;
+            lower(value: CrossChainAcceptedAsset): UniffiByteArray;
+        };
         FfiConverterTypeCrossChainAddressDetails: {
             read(from: RustBuffer): CrossChainAddressDetails;
             write(value: CrossChainAddressDetails, into: RustBuffer): void;
@@ -25504,6 +27334,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): CrossChainProviderContext;
             lower(value: CrossChainProviderContext): UniffiByteArray;
         };
+        FfiConverterTypeCrossChainReceiveInfo: {
+            read(from: RustBuffer): CrossChainReceiveInfo;
+            write(value: CrossChainReceiveInfo, into: RustBuffer): void;
+            allocationSize(value: CrossChainReceiveInfo): number;
+            lift(value: UniffiByteArray): CrossChainReceiveInfo;
+            lower(value: CrossChainReceiveInfo): UniffiByteArray;
+        };
         FfiConverterTypeCrossChainRouteFilter: {
             read(from: RustBuffer): CrossChainRouteFilter;
             write(value: CrossChainRouteFilter, into: RustBuffer): void;
@@ -25511,6 +27348,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): CrossChainRouteFilter;
             lower(value: CrossChainRouteFilter): UniffiByteArray;
         };
+        FfiConverterTypeCrossChainRouteLimits: {
+            read(from: RustBuffer): CrossChainRouteLimits;
+            write(value: CrossChainRouteLimits, into: RustBuffer): void;
+            allocationSize(value: CrossChainRouteLimits): number;
+            lift(value: UniffiByteArray): CrossChainRouteLimits;
+            lower(value: CrossChainRouteLimits): UniffiByteArray;
+        };
         FfiConverterTypeCrossChainRoutePair: {
             read(from: RustBuffer): CrossChainRoutePair;
             write(value: CrossChainRoutePair, into: RustBuffer): void;
@@ -25525,6 +27369,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): CurrencyInfo;
             lower(value: CurrencyInfo): UniffiByteArray;
         };
+        FfiConverterTypeDeliveryMethod: {
+            read(from: RustBuffer): DeliveryMethod;
+            write(value: DeliveryMethod, into: RustBuffer): void;
+            allocationSize(value: DeliveryMethod): number;
+            lift(value: UniffiByteArray): DeliveryMethod;
+            lower(value: DeliveryMethod): UniffiByteArray;
+        };
         FfiConverterTypeDepositClaimError: {
             read(from: RustBuffer): DepositClaimError;
             write(value: DepositClaimError, into: RustBuffer): void;
@@ -25574,6 +27425,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ErrorKind;
             lower(value: ErrorKind): UniffiByteArray;
         };
+        FfiConverterTypeExitChainState: {
+            read(from: RustBuffer): ExitChainState;
+            write(value: ExitChainState, into: RustBuffer): void;
+            allocationSize(value: ExitChainState): number;
+            lift(value: UniffiByteArray): ExitChainState;
+            lower(value: ExitChainState): UniffiByteArray;
+        };
         FfiConverterTypeExitLeafSelection: {
             read(from: RustBuffer): ExitLeafSelection;
             write(value: ExitLeafSelection, into: RustBuffer): void;
@@ -25581,6 +27439,34 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ExitLeafSelection;
             lower(value: ExitLeafSelection): UniffiByteArray;
         };
+        FfiConverterTypeExitNodeConfirmation: {
+            read(from: RustBuffer): ExitNodeConfirmation;
+            write(value: ExitNodeConfirmation, into: RustBuffer): void;
+            allocationSize(value: ExitNodeConfirmation): number;
+            lift(value: UniffiByteArray): ExitNodeConfirmation;
+            lower(value: ExitNodeConfirmation): UniffiByteArray;
+        };
+        FfiConverterTypeExitRefund: {
+            read(from: RustBuffer): ExitRefund;
+            write(value: ExitRefund, into: RustBuffer): void;
+            allocationSize(value: ExitRefund): number;
+            lift(value: UniffiByteArray): ExitRefund;
+            lower(value: ExitRefund): UniffiByteArray;
+        };
+        FfiConverterTypeExitRefundState: {
+            read(from: RustBuffer): ExitRefundState;
+            write(value: ExitRefundState, into: RustBuffer): void;
+            allocationSize(value: ExitRefundState): number;
+            lift(value: UniffiByteArray): ExitRefundState;
+            lower(value: ExitRefundState): UniffiByteArray;
+        };
+        FfiConverterTypeExitTransactionStatus: {
+            read(from: RustBuffer): ExitTransactionStatus;
+            write(value: ExitTransactionStatus, into: RustBuffer): void;
+            allocationSize(value: ExitTransactionStatus): number;
+            lift(value: UniffiByteArray): ExitTransactionStatus;
+            lower(value: ExitTransactionStatus): UniffiByteArray;
+        };
         FfiConverterTypeExportUnilateralExitStateResponse: {
             read(from: RustBuffer): ExportUnilateralExitStateResponse;
             write(value: ExportUnilateralExitStateResponse, into: RustBuffer): void;
@@ -25652,6 +27538,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ExternalInputParser;
             lower(value: ExternalInputParser): UniffiByteArray;
         };
+        FfiConverterTypeExternalLeafSigningKey: {
+            read(from: RustBuffer): ExternalLeafSigningKey;
+            write(value: ExternalLeafSigningKey, into: RustBuffer): void;
+            allocationSize(value: ExternalLeafSigningKey): number;
+            lift(value: UniffiByteArray): ExternalLeafSigningKey;
+            lower(value: ExternalLeafSigningKey): UniffiByteArray;
+        };
         FfiConverterTypeExternalNewLeafKey: {
             read(from: RustBuffer): ExternalNewLeafKey;
             write(value: ExternalNewLeafKey, into: RustBuffer): void;
@@ -26890,20 +28783,6 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): SilentPaymentAddressDetails;
             lower(value: SilentPaymentAddressDetails): UniffiByteArray;
         };
-        FfiConverterTypeSourceAsset: {
-            read(from: RustBuffer): SourceAsset;
-            write(value: SourceAsset, into: RustBuffer): void;
-            allocationSize(value: SourceAsset): number;
-            lift(value: UniffiByteArray): SourceAsset;
-            lower(value: SourceAsset): UniffiByteArray;
-        };
-        FfiConverterTypeSourceChain: {
-            read(from: RustBuffer): SourceChain;
-            write(value: SourceChain, into: RustBuffer): void;
-            allocationSize(value: SourceChain): number;
-            lift(value: UniffiByteArray): SourceChain;
-            lower(value: SourceChain): UniffiByteArray;
-        };
         FfiConverterTypeSparkAddressDetails: {
             read(from: RustBuffer): SparkAddressDetails;
             write(value: SparkAddressDetails, into: RustBuffer): void;
@@ -26911,6 +28790,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): SparkAddressDetails;
             lower(value: SparkAddressDetails): UniffiByteArray;
         };
+        FfiConverterTypeSparkAsset: {
+            read(from: RustBuffer): SparkAsset;
+            write(value: SparkAsset, into: RustBuffer): void;
+            allocationSize(value: SparkAsset): number;
+            lift(value: UniffiByteArray): SparkAsset;
+            lower(value: SparkAsset): UniffiByteArray;
+        };
         FfiConverterTypeSparkConfig: {
             read(from: RustBuffer): SparkConfig;
             write(value: SparkConfig, into: RustBuffer): void;
@@ -27166,6 +29052,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): UnilateralExitLeaf;
             lower(value: UnilateralExitLeaf): UniffiByteArray;
         };
+        FfiConverterTypeUnilateralExitRedoReason: {
+            read(from: RustBuffer): UnilateralExitRedoReason;
+            write(value: UnilateralExitRedoReason, into: RustBuffer): void;
+            allocationSize(value: UnilateralExitRedoReason): number;
+            lift(value: UniffiByteArray): UnilateralExitRedoReason;
+            lower(value: UnilateralExitRedoReason): UniffiByteArray;
+        };
         FfiConverterTypeUnilateralExitRequest: {
             read(from: RustBuffer): UnilateralExitRequest;
             write(value: UnilateralExitRequest, into: RustBuffer): void;
@@ -27194,6 +29087,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): UnilateralExitTxKind;
             lower(value: UnilateralExitTxKind): UniffiByteArray;
         };
+        FfiConverterTypeUnilateralExitVerdict: {
+            read(from: RustBuffer): UnilateralExitVerdict;
+            write(value: UnilateralExitVerdict, into: RustBuffer): void;
+            allocationSize(value: UnilateralExitVerdict): number;
+            lift(value: UniffiByteArray): UnilateralExitVerdict;
+            lower(value: UnilateralExitVerdict): UniffiByteArray;
+        };
         FfiConverterTypeUnregisterWebhookRequest: {
             read(from: RustBuffer): UnregisterWebhookRequest;
             write(value: UnregisterWebhookRequest, into: RustBuffer): void;
@@ -27236,6 +29136,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): UpdateUserSettingsRequest;
             lower(value: UpdateUserSettingsRequest): UniffiByteArray;
         };
+        FfiConverterTypeUpdateWatchedAddressPayload: {
+            read(from: RustBuffer): UpdateWatchedAddressPayload;
+            write(value: UpdateWatchedAddressPayload, into: RustBuffer): void;
+            allocationSize(value: UpdateWatchedAddressPayload): number;
+            lift(value: UniffiByteArray): UpdateWatchedAddressPayload;
+            lower(value: UpdateWatchedAddressPayload): UniffiByteArray;
+        };
         FfiConverterTypeUrlSuccessActionData: {
             read(from: RustBuffer): UrlSuccessActionData;
             write(value: UrlSuccessActionData, into: RustBuffer): void;
@@ -27271,6 +29178,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): WalletSetup;
             lower(value: WalletSetup): UniffiByteArray;
         };
+        FfiConverterTypeWatchedDepositAddress: {
+            read(from: RustBuffer): WatchedDepositAddress;
+            write(value: WatchedDepositAddress, into: RustBuffer): void;
+            allocationSize(value: WatchedDepositAddress): number;
+            lift(value: UniffiByteArray): WatchedDepositAddress;
+            lower(value: WatchedDepositAddress): UniffiByteArray;
+        };
         FfiConverterTypeWebhook: {
             read(from: RustBuffer): Webhook;
             write(value: Webhook, into: RustBuffer): void;