@breeztech/breez-sdk-spark-react-native 0.19.2 → 0.21.0

package/src/generated/breez_sdk_spark.ts

@@ -32,6 +32,7 @@ import nativeModule, {
   type UniffiVTableCallbackInterfaceEventListener,
   type UniffiVTableCallbackInterfaceLogger,
   type UniffiVTableCallbackInterfaceBitcoinChainService,
+  type UniffiVTableCallbackInterfaceCpfpSigner,
   type UniffiVTableCallbackInterfaceExternalBreezSigner,
   type UniffiVTableCallbackInterfaceExternalSigningSigner,
   type UniffiVTableCallbackInterfaceExternalSparkSigner,
@@ -683,6 +684,28 @@ export async function newSharedSdkContext(
     throw __error;
   }
 }
+/**
+ * A CPFP signer backed by a single private key. Signs P2WPKH and P2TR key-path
+ * inputs only; taproot script-path spends are not supported.
+ */
+export function singleKeyCpfpSigner(
+  secretKeyBytes: ArrayBuffer
+): CpfpSigner /*throws*/ {
+  return FfiConverterTypeCpfpSigner.lift(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeSignerError.lift.bind(
+        FfiConverterTypeSignerError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_func_single_key_cpfp_signer(
+          FfiConverterArrayBuffer.lower(secretKeyBytes),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift
+    )
+  );
+}
 
 /**
  * Trait for event listeners
@@ -1073,6 +1096,149 @@ const FfiConverterTypeAuthorizeTransferRequest = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * A single payee in a batch send.
+ */
+export type BatchRecipient = {
+  /**
+   * Spark address or Spark invoice identifying the payee.
+   */
+  paymentRequest: string;
+  /**
+   * Amount to send, in the base units of the asset being sent. Required
+   * unless `payment_request` is an invoice that carries its own amount.
+   */
+  amount: U128 | undefined;
+  /**
+   * Token to send. Unset means sats, which a batch cannot send yet, so a
+   * plain address needs this set. An invoice that names a token does not.
+   */
+  tokenIdentifier: string | undefined;
+};
+
+/**
+ * Generated factory for {@link BatchRecipient} record objects.
+ */
+export const BatchRecipient = (() => {
+  const defaults = () => ({ amount: undefined, tokenIdentifier: undefined });
+  const create = (() => {
+    return uniffiCreateRecord<BatchRecipient, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link BatchRecipient}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link BatchRecipient}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<BatchRecipient>,
+  });
+})();
+
+const FfiConverterTypeBatchRecipient = (() => {
+  type TypeName = BatchRecipient;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        paymentRequest: FfiConverterString.read(from),
+        amount: FfiConverterOptionalTypeu128.read(from),
+        tokenIdentifier: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.paymentRequest, into);
+      FfiConverterOptionalTypeu128.write(value.amount, into);
+      FfiConverterOptionalString.write(value.tokenIdentifier, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.paymentRequest) +
+        FfiConverterOptionalTypeu128.allocationSize(value.amount) +
+        FfiConverterOptionalString.allocationSize(value.tokenIdentifier)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * What a batch debits for one asset.
+ */
+export type BatchTotal = {
+  /**
+   * The token debited. Unset means sats, which a batch cannot send yet.
+   */
+  tokenIdentifier: string | undefined;
+  /**
+   * Amount in the asset's base units.
+   */
+  amount: U128;
+};
+
+/**
+ * Generated factory for {@link BatchTotal} record objects.
+ */
+export const BatchTotal = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<BatchTotal, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link BatchTotal}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link BatchTotal}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<BatchTotal>,
+  });
+})();
+
+const FfiConverterTypeBatchTotal = (() => {
+  type TypeName = BatchTotal;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        tokenIdentifier: FfiConverterOptionalString.read(from),
+        amount: FfiConverterTypeu128.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.tokenIdentifier, into);
+      FfiConverterTypeu128.write(value.amount, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterOptionalString.allocationSize(value.tokenIdentifier) +
+        FfiConverterTypeu128.allocationSize(value.amount)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type Bip21Details = {
   amountSat: /*u64*/ bigint | undefined;
   assetId: string | undefined;
@@ -1940,6 +2106,65 @@ const FfiConverterTypeBolt12OfferDetails = (() => {
   return new FFIConverter();
 })();
 
+export type BuildUnsignedBatchPackageRequest = {
+  prepareResponse: PrepareSendBatchResponse;
+};
+
+/**
+ * Generated factory for {@link BuildUnsignedBatchPackageRequest} record objects.
+ */
+export const BuildUnsignedBatchPackageRequest = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      BuildUnsignedBatchPackageRequest,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link BuildUnsignedBatchPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link BuildUnsignedBatchPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<BuildUnsignedBatchPackageRequest>,
+  });
+})();
+
+const FfiConverterTypeBuildUnsignedBatchPackageRequest = (() => {
+  type TypeName = BuildUnsignedBatchPackageRequest;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        prepareResponse: FfiConverterTypePrepareSendBatchResponse.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypePrepareSendBatchResponse.write(
+        value.prepareResponse,
+        into
+      );
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterTypePrepareSendBatchResponse.allocationSize(
+        value.prepareResponse
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type BuildUnsignedLnurlPayPackageRequest = {
   prepareResponse: PrepareLnurlPayResponse;
 };
@@ -3963,6 +4188,77 @@ const FfiConverterTypeCreateIssuerTokenRequest = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * A newly created credential, plus the PRF outputs when the platform
+ * evaluated them during the create ceremony itself.
+ *
+ * `seeds` present means no assertion is needed: the caller skips the
+ * second ceremony, and with it the window in which a credential exists
+ * but is not yet resolvable. Absent means the platform returned no PRF
+ * results at create (or dropped one of a pair), so the caller derives
+ * through [`super::PrfProvider::derive_seeds`] as before.
+ */
+export type CreatePasskeyOutput = {
+  credential: PasskeyCredential;
+  /**
+   * One output per requested salt, in request order.
+   */
+  seeds: Array<ArrayBuffer> | undefined;
+};
+
+/**
+ * Generated factory for {@link CreatePasskeyOutput} record objects.
+ */
+export const CreatePasskeyOutput = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<CreatePasskeyOutput, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link CreatePasskeyOutput}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link CreatePasskeyOutput}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<CreatePasskeyOutput>,
+  });
+})();
+
+const FfiConverterTypeCreatePasskeyOutput = (() => {
+  type TypeName = CreatePasskeyOutput;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        credential: FfiConverterTypePasskeyCredential.read(from),
+        seeds: FfiConverterOptionalArrayArrayBuffer.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypePasskeyCredential.write(value.credential, into);
+      FfiConverterOptionalArrayArrayBuffer.write(value.seeds, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypePasskeyCredential.allocationSize(value.credential) +
+        FfiConverterOptionalArrayArrayBuffer.allocationSize(value.seeds)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type Credentials = {
   username: string;
   password: string;
@@ -10644,6 +10940,73 @@ const FfiConverterTypePaymentRequestSource = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * How much to fund one branch of the exit to avoid a fan-out.
+ */
+export type PerBranchFunding = {
+  /**
+   * The leaf whose branch this funds.
+   */
+  leafId: string;
+  /**
+   * Fund a UTXO of at least this many satoshis for this branch.
+   */
+  fundingSat: /*u64*/ bigint;
+};
+
+/**
+ * Generated factory for {@link PerBranchFunding} record objects.
+ */
+export const PerBranchFunding = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<PerBranchFunding, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PerBranchFunding}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link PerBranchFunding}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<PerBranchFunding>,
+  });
+})();
+
+const FfiConverterTypePerBranchFunding = (() => {
+  type TypeName = PerBranchFunding;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        leafId: FfiConverterString.read(from),
+        fundingSat: FfiConverterUInt64.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.leafId, into);
+      FfiConverterUInt64.write(value.fundingSat, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.leafId) +
+        FfiConverterUInt64.allocationSize(value.fundingSat)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type PrepareLnurlPayRequest = {
   /**
    * The amount to send. Denominated in satoshis, or in token base units
@@ -10866,6 +11229,135 @@ const FfiConverterTypePrepareLnurlPayResponse = (() => {
   return new FFIConverter();
 })();
 
+export type PrepareSendBatchRequest = {
+  /**
+   * The payees, all paid by one transaction. They may span several tokens,
+   * and may mix Spark addresses with Spark invoices. Once a Spark invoice is
+   * among them, every recipient must be paid in the same token.
+   */
+  recipients: Array<BatchRecipient>;
+};
+
+/**
+ * Generated factory for {@link PrepareSendBatchRequest} record objects.
+ */
+export const PrepareSendBatchRequest = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      PrepareSendBatchRequest,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PrepareSendBatchRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link PrepareSendBatchRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<PrepareSendBatchRequest>,
+  });
+})();
+
+const FfiConverterTypePrepareSendBatchRequest = (() => {
+  type TypeName = PrepareSendBatchRequest;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        recipients: FfiConverterArrayTypeBatchRecipient.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayTypeBatchRecipient.write(value.recipients, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterArrayTypeBatchRecipient.allocationSize(
+        value.recipients
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type PrepareSendBatchResponse = {
+  /**
+   * The payees in the order they were requested, which is the order their
+   * payments come back in.
+   */
+  recipients: Array<ResolvedBatchRecipient>;
+  /**
+   * What the batch debits, one entry per distinct asset.
+   */
+  totals: Array<BatchTotal>;
+};
+
+/**
+ * Generated factory for {@link PrepareSendBatchResponse} record objects.
+ */
+export const PrepareSendBatchResponse = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      PrepareSendBatchResponse,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PrepareSendBatchResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link PrepareSendBatchResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<PrepareSendBatchResponse>,
+  });
+})();
+
+const FfiConverterTypePrepareSendBatchResponse = (() => {
+  type TypeName = PrepareSendBatchResponse;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        recipients: FfiConverterArrayTypeResolvedBatchRecipient.read(from),
+        totals: FfiConverterArrayTypeBatchTotal.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayTypeResolvedBatchRecipient.write(value.recipients, into);
+      FfiConverterArrayTypeBatchTotal.write(value.totals, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterArrayTypeResolvedBatchRecipient.allocationSize(
+          value.recipients
+        ) + FfiConverterArrayTypeBatchTotal.allocationSize(value.totals)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type PrepareSendPaymentRequest = {
   paymentRequest: PaymentRequest;
   /**
@@ -11065,6 +11557,198 @@ const FfiConverterTypePrepareSendPaymentResponse = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Request for `prepare_unilateral_exit`, the exit quote.
+ */
+export type PrepareUnilateralExitRequest = {
+  /**
+   * Target fee rate in sat/vByte, applied to every CPFP child, the fan-out,
+   * and the sweep.
+   */
+  feeRateSatPerVbyte: /*u64*/ bigint;
+  fundingKind: CpfpFundingKind;
+  /**
+   * The Bitcoin address the swept funds are sent to.
+   */
+  destination: string;
+  selection: ExitLeafSelection;
+};
+
+/**
+ * Generated factory for {@link PrepareUnilateralExitRequest} record objects.
+ */
+export const PrepareUnilateralExitRequest = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      PrepareUnilateralExitRequest,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PrepareUnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link PrepareUnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<PrepareUnilateralExitRequest>,
+  });
+})();
+
+const FfiConverterTypePrepareUnilateralExitRequest = (() => {
+  type TypeName = PrepareUnilateralExitRequest;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        feeRateSatPerVbyte: FfiConverterUInt64.read(from),
+        fundingKind: FfiConverterTypeCpfpFundingKind.read(from),
+        destination: FfiConverterString.read(from),
+        selection: FfiConverterTypeExitLeafSelection.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt64.write(value.feeRateSatPerVbyte, into);
+      FfiConverterTypeCpfpFundingKind.write(value.fundingKind, into);
+      FfiConverterString.write(value.destination, into);
+      FfiConverterTypeExitLeafSelection.write(value.selection, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt64.allocationSize(value.feeRateSatPerVbyte) +
+        FfiConverterTypeCpfpFundingKind.allocationSize(value.fundingKind) +
+        FfiConverterString.allocationSize(value.destination) +
+        FfiConverterTypeExitLeafSelection.allocationSize(value.selection)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Response from `prepare_unilateral_exit`: which leaves would exit, the exact
+ * fee at the requested rate, and how much to fund.
+ */
+export type PrepareUnilateralExitResponse = {
+  leaves: Array<UnilateralExitLeaf>;
+  /**
+   * Total value of the selected leaves, in satoshis.
+   */
+  recoverableValueSat: /*u64*/ bigint;
+  /**
+   * Total on-chain fee when funding with a single UTXO (fanned out across
+   * 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.
+   */
+  totalFeeSat: /*u64*/ 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).
+   */
+  fanoutFeeSat: /*u64*/ bigint;
+  /**
+   * Fund a single UTXO of at least this many satoshis to exit with a fan-out.
+   */
+  singleUtxoFundingSat: /*u64*/ bigint;
+  /**
+   * To skip the fan-out, fund one UTXO per branch of at least the given
+   * amount (one entry per selected leaf).
+   */
+  perBranchFunding: Array<PerBranchFunding>;
+  /**
+   * The fee rate this quote was computed at, in sat/vByte.
+   */
+  feeRateSatPerVbyte: /*u64*/ bigint;
+  destination: string;
+};
+
+/**
+ * Generated factory for {@link PrepareUnilateralExitResponse} record objects.
+ */
+export const PrepareUnilateralExitResponse = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      PrepareUnilateralExitResponse,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PrepareUnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link PrepareUnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<PrepareUnilateralExitResponse>,
+  });
+})();
+
+const FfiConverterTypePrepareUnilateralExitResponse = (() => {
+  type TypeName = PrepareUnilateralExitResponse;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        leaves: FfiConverterArrayTypeUnilateralExitLeaf.read(from),
+        recoverableValueSat: FfiConverterUInt64.read(from),
+        totalFeeSat: FfiConverterUInt64.read(from),
+        fanoutFeeSat: FfiConverterUInt64.read(from),
+        singleUtxoFundingSat: FfiConverterUInt64.read(from),
+        perBranchFunding: FfiConverterArrayTypePerBranchFunding.read(from),
+        feeRateSatPerVbyte: FfiConverterUInt64.read(from),
+        destination: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayTypeUnilateralExitLeaf.write(value.leaves, into);
+      FfiConverterUInt64.write(value.recoverableValueSat, into);
+      FfiConverterUInt64.write(value.totalFeeSat, into);
+      FfiConverterUInt64.write(value.fanoutFeeSat, into);
+      FfiConverterUInt64.write(value.singleUtxoFundingSat, into);
+      FfiConverterArrayTypePerBranchFunding.write(value.perBranchFunding, into);
+      FfiConverterUInt64.write(value.feeRateSatPerVbyte, into);
+      FfiConverterString.write(value.destination, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterArrayTypeUnilateralExitLeaf.allocationSize(value.leaves) +
+        FfiConverterUInt64.allocationSize(value.recoverableValueSat) +
+        FfiConverterUInt64.allocationSize(value.totalFeeSat) +
+        FfiConverterUInt64.allocationSize(value.fanoutFeeSat) +
+        FfiConverterUInt64.allocationSize(value.singleUtxoFundingSat) +
+        FfiConverterArrayTypePerBranchFunding.allocationSize(
+          value.perBranchFunding
+        ) +
+        FfiConverterUInt64.allocationSize(value.feeRateSatPerVbyte) +
+        FfiConverterString.allocationSize(value.destination)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type ProvisionalPayment = {
   /**
    * Unique identifier for the payment
@@ -11920,6 +12604,84 @@ const FfiConverterTypeRefundDepositResponse = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Response from refunding pending conversions.
+ */
+export type RefundPendingConversionsResponse = {
+  /**
+   * Conversions successfully refunded this pass.
+   */
+  refunded: /*u32*/ number;
+  /**
+   * Conversions intentionally deferred (eligible but held back by a
+   * safety window). The next pass will retry them.
+   */
+  skipped: /*u32*/ number;
+  /**
+   * Conversions whose clawback did not complete this pass (rejected or
+   * errored; funds not returned). The next pass will retry them.
+   */
+  failed: /*u32*/ number;
+};
+
+/**
+ * Generated factory for {@link RefundPendingConversionsResponse} record objects.
+ */
+export const RefundPendingConversionsResponse = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      RefundPendingConversionsResponse,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link RefundPendingConversionsResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link RefundPendingConversionsResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<RefundPendingConversionsResponse>,
+  });
+})();
+
+const FfiConverterTypeRefundPendingConversionsResponse = (() => {
+  type TypeName = RefundPendingConversionsResponse;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        refunded: FfiConverterUInt32.read(from),
+        skipped: FfiConverterUInt32.read(from),
+        failed: FfiConverterUInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.refunded, into);
+      FfiConverterUInt32.write(value.skipped, into);
+      FfiConverterUInt32.write(value.failed, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.refunded) +
+        FfiConverterUInt32.allocationSize(value.skipped) +
+        FfiConverterUInt32.allocationSize(value.failed)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type RegisterLightningAddressRequest = {
   username: string;
   description: string | undefined;
@@ -12267,6 +13029,80 @@ const FfiConverterTypeRegisterWebhookResponse = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * A recipient after prepare has resolved the asset and amount it is owed.
+ */
+export type ResolvedBatchRecipient = {
+  destination: BatchDestination;
+  /**
+   * Amount in the base units of the asset this recipient is paid in.
+   */
+  amount: U128;
+  /**
+   * The token this recipient is paid in. Unset means sats, which a batch
+   * cannot send yet.
+   */
+  tokenIdentifier: string | undefined;
+};
+
+/**
+ * Generated factory for {@link ResolvedBatchRecipient} record objects.
+ */
+export const ResolvedBatchRecipient = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      ResolvedBatchRecipient,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ResolvedBatchRecipient}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ResolvedBatchRecipient}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<ResolvedBatchRecipient>,
+  });
+})();
+
+const FfiConverterTypeResolvedBatchRecipient = (() => {
+  type TypeName = ResolvedBatchRecipient;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        destination: FfiConverterTypeBatchDestination.read(from),
+        amount: FfiConverterTypeu128.read(from),
+        tokenIdentifier: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeBatchDestination.write(value.destination, into);
+      FfiConverterTypeu128.write(value.amount, into);
+      FfiConverterOptionalString.write(value.tokenIdentifier, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeBatchDestination.allocationSize(value.destination) +
+        FfiConverterTypeu128.allocationSize(value.amount) +
+        FfiConverterOptionalString.allocationSize(value.tokenIdentifier)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type RestResponse = {
   status: /*u16*/ number;
   body: string;
@@ -12537,6 +13373,119 @@ const FfiConverterTypeSecretBytes = (() => {
   return new FFIConverter();
 })();
 
+export type SendBatchRequest = {
+  prepareResponse: PrepareSendBatchResponse;
+};
+
+/**
+ * Generated factory for {@link SendBatchRequest} record objects.
+ */
+export const SendBatchRequest = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<SendBatchRequest, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link SendBatchRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link SendBatchRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<SendBatchRequest>,
+  });
+})();
+
+const FfiConverterTypeSendBatchRequest = (() => {
+  type TypeName = SendBatchRequest;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        prepareResponse: FfiConverterTypePrepareSendBatchResponse.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypePrepareSendBatchResponse.write(
+        value.prepareResponse,
+        into
+      );
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterTypePrepareSendBatchResponse.allocationSize(
+        value.prepareResponse
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type SendBatchResponse = {
+  /**
+   * One payment per recipient, in recipient order, all sharing a transaction
+   * hash.
+   */
+  payments: Array<Payment>;
+};
+
+/**
+ * Generated factory for {@link SendBatchResponse} record objects.
+ */
+export const SendBatchResponse = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<SendBatchResponse, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link SendBatchResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link SendBatchResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<SendBatchResponse>,
+  });
+})();
+
+const FfiConverterTypeSendBatchResponse = (() => {
+  type TypeName = SendBatchResponse;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        payments: FfiConverterArrayTypePayment.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayTypePayment.write(value.payments, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterArrayTypePayment.allocationSize(value.payments);
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type SendOnchainFeeQuote = {
   id: string;
   expiresAt: /*u64*/ bigint;
@@ -15538,6 +16487,336 @@ const FfiConverterTypeUnfreezeIssuerTokenResponse = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * A leaf selected for exit, with its value.
+ */
+export type UnilateralExitLeaf = {
+  leafId: string;
+  /**
+   * The leaf's value in satoshis.
+   */
+  value: /*u64*/ bigint;
+};
+
+/**
+ * Generated factory for {@link UnilateralExitLeaf} record objects.
+ */
+export const UnilateralExitLeaf = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<UnilateralExitLeaf, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link UnilateralExitLeaf}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link UnilateralExitLeaf}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<UnilateralExitLeaf>,
+  });
+})();
+
+const FfiConverterTypeUnilateralExitLeaf = (() => {
+  type TypeName = UnilateralExitLeaf;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        leafId: FfiConverterString.read(from),
+        value: FfiConverterUInt64.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.leafId, into);
+      FfiConverterUInt64.write(value.value, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.leafId) +
+        FfiConverterUInt64.allocationSize(value.value)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Request for `unilateral_exit`: a `prepare_unilateral_exit` quote plus the
+ * funding UTXOs that pay its fees. The signer is passed separately (it is not a
+ * plain data value).
+ */
+export type UnilateralExitRequest = {
+  /**
+   * The quote returned by `prepare_unilateral_exit`, naming the leaves to exit.
+   */
+  prepared: PrepareUnilateralExitResponse;
+  /**
+   * The funding UTXOs that pay the exit's on-chain fees, meeting the quote's
+   * `single_utxo_funding_sat` (one UTXO) or `per_branch_funding` (one per branch).
+   */
+  fundingInputs: Array<CpfpInput>;
+};
+
+/**
+ * Generated factory for {@link UnilateralExitRequest} record objects.
+ */
+export const UnilateralExitRequest = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      UnilateralExitRequest,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link UnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link UnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<UnilateralExitRequest>,
+  });
+})();
+
+const FfiConverterTypeUnilateralExitRequest = (() => {
+  type TypeName = UnilateralExitRequest;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        prepared: FfiConverterTypePrepareUnilateralExitResponse.read(from),
+        fundingInputs: FfiConverterArrayTypeCpfpInput.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypePrepareUnilateralExitResponse.write(value.prepared, into);
+      FfiConverterArrayTypeCpfpInput.write(value.fundingInputs, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypePrepareUnilateralExitResponse.allocationSize(
+          value.prepared
+        ) + FfiConverterArrayTypeCpfpInput.allocationSize(value.fundingInputs)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Result of `unilateral_exit`: a cost summary plus the complete, signed exit
+ * path.
+ */
+export type UnilateralExitResponse = {
+  /**
+   * Total value of the selected leaves, in satoshis.
+   */
+  recoverableValueSat: /*u64*/ bigint;
+  /**
+   * 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.
+   */
+  totalFeeSat: /*u64*/ 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>;
+};
+
+/**
+ * Generated factory for {@link UnilateralExitResponse} record objects.
+ */
+export const UnilateralExitResponse = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      UnilateralExitResponse,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link UnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link UnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<UnilateralExitResponse>,
+  });
+})();
+
+const FfiConverterTypeUnilateralExitResponse = (() => {
+  type TypeName = UnilateralExitResponse;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        recoverableValueSat: FfiConverterUInt64.read(from),
+        totalFeeSat: FfiConverterUInt64.read(from),
+        leaves: FfiConverterArrayTypeUnilateralExitLeaf.read(from),
+        transactions: FfiConverterArrayTypeUnilateralExitTransaction.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt64.write(value.recoverableValueSat, into);
+      FfiConverterUInt64.write(value.totalFeeSat, into);
+      FfiConverterArrayTypeUnilateralExitLeaf.write(value.leaves, into);
+      FfiConverterArrayTypeUnilateralExitTransaction.write(
+        value.transactions,
+        into
+      );
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt64.allocationSize(value.recoverableValueSat) +
+        FfiConverterUInt64.allocationSize(value.totalFeeSat) +
+        FfiConverterArrayTypeUnilateralExitLeaf.allocationSize(value.leaves) +
+        FfiConverterArrayTypeUnilateralExitTransaction.allocationSize(
+          value.transactions
+        )
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * One transaction in the unilateral exit path, with everything needed to
+ * order and broadcast it.
+ */
+export type UnilateralExitTransaction = {
+  kind: UnilateralExitTxKind;
+  /**
+   * The tree node this transaction belongs to. Unset for the fan-out and the
+   * sweep.
+   */
+  nodeId: string | undefined;
+  txid: string;
+  txHex: string;
+  /**
+   * The signed CPFP child to broadcast alongside `tx_hex` as a package.
+   * Unset for the fan-out and the sweep (no anchor to bump) and for a
+   * `Confirmed` step (its CPFP is already on-chain).
+   */
+  cpfpTxHex: string | undefined;
+  /**
+   * Relative CSV timelock, in blocks, that must mature on the spent input
+   * before this transaction can confirm. Unset when there is no timelock.
+   */
+  csvTimelockBlocks: /*u32*/ number | undefined;
+  /**
+   * Txids of other entries in this list that must be confirmed before this
+   * one can be broadcast.
+   */
+  dependsOn: Array<string>;
+  status: ConfirmationStatus;
+};
+
+/**
+ * Generated factory for {@link UnilateralExitTransaction} record objects.
+ */
+export const UnilateralExitTransaction = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<
+      UnilateralExitTransaction,
+      ReturnType<typeof defaults>
+    >(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link UnilateralExitTransaction}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link UnilateralExitTransaction}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () =>
+      Object.freeze(defaults()) as Partial<UnilateralExitTransaction>,
+  });
+})();
+
+const FfiConverterTypeUnilateralExitTransaction = (() => {
+  type TypeName = UnilateralExitTransaction;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        kind: FfiConverterTypeUnilateralExitTxKind.read(from),
+        nodeId: FfiConverterOptionalString.read(from),
+        txid: FfiConverterString.read(from),
+        txHex: FfiConverterString.read(from),
+        cpfpTxHex: FfiConverterOptionalString.read(from),
+        csvTimelockBlocks: FfiConverterOptionalUInt32.read(from),
+        dependsOn: FfiConverterArrayString.read(from),
+        status: FfiConverterTypeConfirmationStatus.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeUnilateralExitTxKind.write(value.kind, into);
+      FfiConverterOptionalString.write(value.nodeId, into);
+      FfiConverterString.write(value.txid, into);
+      FfiConverterString.write(value.txHex, into);
+      FfiConverterOptionalString.write(value.cpfpTxHex, into);
+      FfiConverterOptionalUInt32.write(value.csvTimelockBlocks, into);
+      FfiConverterArrayString.write(value.dependsOn, into);
+      FfiConverterTypeConfirmationStatus.write(value.status, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeUnilateralExitTxKind.allocationSize(value.kind) +
+        FfiConverterOptionalString.allocationSize(value.nodeId) +
+        FfiConverterString.allocationSize(value.txid) +
+        FfiConverterString.allocationSize(value.txHex) +
+        FfiConverterOptionalString.allocationSize(value.cpfpTxHex) +
+        FfiConverterOptionalUInt32.allocationSize(value.csvTimelockBlocks) +
+        FfiConverterArrayString.allocationSize(value.dependsOn) +
+        FfiConverterTypeConfirmationStatus.allocationSize(value.status)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * Request to unregister an existing webhook.
  */
@@ -15737,13 +17016,24 @@ export type UpdateUserSettingsRequest = {
    * Update the active stable balance token. `None` means no change.
    */
   stableBalanceActiveLabel: StableBalanceActiveLabel | undefined;
+  /**
+   * Designate or remove the wallet's master identity, a second public key
+   * the Spark operators accept as a reader of this wallet's balance and
+   * history while `spark_private_mode_enabled` is set. The master identity
+   * can only read: payments still require the owner's keys. `None` means no
+   * change.
+   */
+  sparkMasterIdentityPublicKey: SparkMasterIdentityPublicKey | undefined;
 };
 
 /**
  * Generated factory for {@link UpdateUserSettingsRequest} record objects.
  */
 export const UpdateUserSettingsRequest = (() => {
-  const defaults = () => ({ stableBalanceActiveLabel: undefined });
+  const defaults = () => ({
+    stableBalanceActiveLabel: undefined,
+    sparkMasterIdentityPublicKey: undefined,
+  });
   const create = (() => {
     return uniffiCreateRecord<
       UpdateUserSettingsRequest,
@@ -15779,6 +17069,8 @@ const FfiConverterTypeUpdateUserSettingsRequest = (() => {
         sparkPrivateModeEnabled: FfiConverterOptionalBool.read(from),
         stableBalanceActiveLabel:
           FfiConverterOptionalTypeStableBalanceActiveLabel.read(from),
+        sparkMasterIdentityPublicKey:
+          FfiConverterOptionalTypeSparkMasterIdentityPublicKey.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
@@ -15787,12 +17079,19 @@ const FfiConverterTypeUpdateUserSettingsRequest = (() => {
         value.stableBalanceActiveLabel,
         into
       );
+      FfiConverterOptionalTypeSparkMasterIdentityPublicKey.write(
+        value.sparkMasterIdentityPublicKey,
+        into
+      );
     }
     allocationSize(value: TypeName): number {
       return (
         FfiConverterOptionalBool.allocationSize(value.sparkPrivateModeEnabled) +
         FfiConverterOptionalTypeStableBalanceActiveLabel.allocationSize(
           value.stableBalanceActiveLabel
+        ) +
+        FfiConverterOptionalTypeSparkMasterIdentityPublicKey.allocationSize(
+          value.sparkMasterIdentityPublicKey
         )
       );
     }
@@ -15880,6 +17179,11 @@ export type UserSettings = {
    * The label of the currently active stable balance token, or `None` if deactivated.
    */
   stableBalanceActiveLabel: string | undefined;
+  /**
+   * The hex encoded public key designated as this wallet's master identity
+   * key, or `None` if none is designated.
+   */
+  sparkMasterIdentityPublicKey: string | undefined;
 };
 
 /**
@@ -15919,17 +17223,25 @@ const FfiConverterTypeUserSettings = (() => {
       return {
         sparkPrivateModeEnabled: FfiConverterBool.read(from),
         stableBalanceActiveLabel: FfiConverterOptionalString.read(from),
+        sparkMasterIdentityPublicKey: FfiConverterOptionalString.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
       FfiConverterBool.write(value.sparkPrivateModeEnabled, into);
       FfiConverterOptionalString.write(value.stableBalanceActiveLabel, into);
+      FfiConverterOptionalString.write(
+        value.sparkMasterIdentityPublicKey,
+        into
+      );
     }
     allocationSize(value: TypeName): number {
       return (
         FfiConverterBool.allocationSize(value.sparkPrivateModeEnabled) +
         FfiConverterOptionalString.allocationSize(
           value.stableBalanceActiveLabel
+        ) +
+        FfiConverterOptionalString.allocationSize(
+          value.sparkMasterIdentityPublicKey
         )
       );
     }
@@ -17085,6 +18397,150 @@ const FfiConverterTypeAutoOptimizationEvent = (() => {
   return new FFIConverter();
 })();
 
+// Enum: BatchDestination
+export enum BatchDestination_Tags {
+  SparkAddress = 'SparkAddress',
+  SparkInvoice = 'SparkInvoice',
+}
+/**
+ * Where a batch recipient is paid, once prepare has decoded its payment request.
+ */
+export const BatchDestination = (() => {
+  type SparkAddress__interface = {
+    tag: BatchDestination_Tags.SparkAddress;
+    inner: Readonly<{ address: string }>;
+  };
+
+  class SparkAddress_ extends UniffiEnum implements SparkAddress__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'BatchDestination';
+    readonly tag = BatchDestination_Tags.SparkAddress;
+    readonly inner: Readonly<{ address: string }>;
+    constructor(inner: { address: string }) {
+      super('BatchDestination', 'SparkAddress');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { address: string }): SparkAddress_ {
+      return new SparkAddress_(inner);
+    }
+
+    static instanceOf(obj: any): obj is SparkAddress_ {
+      return obj.tag === BatchDestination_Tags.SparkAddress;
+    }
+  }
+
+  type SparkInvoice__interface = {
+    tag: BatchDestination_Tags.SparkInvoice;
+    inner: Readonly<{ invoiceDetails: SparkInvoiceDetails }>;
+  };
+
+  class SparkInvoice_ extends UniffiEnum implements SparkInvoice__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'BatchDestination';
+    readonly tag = BatchDestination_Tags.SparkInvoice;
+    readonly inner: Readonly<{ invoiceDetails: SparkInvoiceDetails }>;
+    constructor(inner: { invoiceDetails: SparkInvoiceDetails }) {
+      super('BatchDestination', 'SparkInvoice');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { invoiceDetails: SparkInvoiceDetails }): SparkInvoice_ {
+      return new SparkInvoice_(inner);
+    }
+
+    static instanceOf(obj: any): obj is SparkInvoice_ {
+      return obj.tag === BatchDestination_Tags.SparkInvoice;
+    }
+  }
+
+  function instanceOf(obj: any): obj is BatchDestination {
+    return obj[uniffiTypeNameSymbol] === 'BatchDestination';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    SparkAddress: SparkAddress_,
+    SparkInvoice: SparkInvoice_,
+  });
+})();
+
+/**
+ * Where a batch recipient is paid, once prepare has decoded its payment request.
+ */
+
+export type BatchDestination = InstanceType<
+  (typeof BatchDestination)[keyof Omit<typeof BatchDestination, 'instanceOf'>]
+>;
+
+// FfiConverter for enum BatchDestination
+const FfiConverterTypeBatchDestination = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = BatchDestination;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new BatchDestination.SparkAddress({
+            address: FfiConverterString.read(from),
+          });
+        case 2:
+          return new BatchDestination.SparkInvoice({
+            invoiceDetails: FfiConverterTypeSparkInvoiceDetails.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case BatchDestination_Tags.SparkAddress: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.address, into);
+          return;
+        }
+        case BatchDestination_Tags.SparkInvoice: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterTypeSparkInvoiceDetails.write(inner.invoiceDetails, into);
+          return;
+        }
+        default:
+          // Throwing from here means that BatchDestination_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case BatchDestination_Tags.SparkAddress: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.address);
+          return size;
+        }
+        case BatchDestination_Tags.SparkInvoice: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterTypeSparkInvoiceDetails.allocationSize(
+            inner.invoiceDetails
+          );
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
 export enum BitcoinNetwork {
   /**
    * Mainnet
@@ -17750,6 +19206,58 @@ const FfiConverterTypeChainServiceError = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Whether a transaction in the exit path is already on-chain.
+ */
+export enum ConfirmationStatus {
+  /**
+   * This transaction is confirmed in a block. It needs no action.
+   */
+  Confirmed,
+  /**
+   * This transaction is not yet confirmed. Mempool state is not consulted.
+   */
+  Unconfirmed,
+  /**
+   * The on-chain status could not be determined (the chain service errored).
+   * Broadcasting may fail if a conflicting transaction already landed.
+   */
+  Unverified,
+}
+
+const FfiConverterTypeConfirmationStatus = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = ConfirmationStatus;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return ConfirmationStatus.Confirmed;
+        case 2:
+          return ConfirmationStatus.Unconfirmed;
+        case 3:
+          return ConfirmationStatus.Unverified;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case ConfirmationStatus.Confirmed:
+          return ordinalConverter.write(1, into);
+        case ConfirmationStatus.Unconfirmed:
+          return ordinalConverter.write(2, into);
+        case ConfirmationStatus.Unverified:
+          return ordinalConverter.write(3, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
 // Enum: ConversionChain
 export enum ConversionChain_Tags {
   Spark = 'Spark',
@@ -19155,6 +20663,500 @@ const FfiConverterTypeConversionType = (() => {
   return new FFIConverter();
 })();
 
+// Enum: CpfpFundingKind
+export enum CpfpFundingKind_Tags {
+  P2wpkh = 'P2wpkh',
+  P2tr = 'P2tr',
+  Custom = 'Custom',
+}
+/**
+ * The kind of UTXO that will fund an exit's fees.
+ */
+export const CpfpFundingKind = (() => {
+  type P2wpkh__interface = {
+    tag: CpfpFundingKind_Tags.P2wpkh;
+  };
+
+  /**
+   * Fees paid from P2WPKH (native segwit v0) UTXOs.
+   */
+  class P2wpkh_ extends UniffiEnum implements P2wpkh__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'CpfpFundingKind';
+    readonly tag = CpfpFundingKind_Tags.P2wpkh;
+    constructor() {
+      super('CpfpFundingKind', 'P2wpkh');
+    }
+
+    static new(): P2wpkh_ {
+      return new P2wpkh_();
+    }
+
+    static instanceOf(obj: any): obj is P2wpkh_ {
+      return obj.tag === CpfpFundingKind_Tags.P2wpkh;
+    }
+  }
+
+  type P2tr__interface = {
+    tag: CpfpFundingKind_Tags.P2tr;
+  };
+
+  /**
+   * Fees paid from P2TR (taproot, key-path) UTXOs.
+   */
+  class P2tr_ extends UniffiEnum implements P2tr__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'CpfpFundingKind';
+    readonly tag = CpfpFundingKind_Tags.P2tr;
+    constructor() {
+      super('CpfpFundingKind', 'P2tr');
+    }
+
+    static new(): P2tr_ {
+      return new P2tr_();
+    }
+
+    static instanceOf(obj: any): obj is P2tr_ {
+      return obj.tag === CpfpFundingKind_Tags.P2tr;
+    }
+  }
+
+  type Custom__interface = {
+    tag: CpfpFundingKind_Tags.Custom;
+    inner: Readonly<{
+      scriptPubkeyHex: string;
+      signedInputWeight: /*u64*/ bigint;
+    }>;
+  };
+
+  /**
+   * Fees paid from a custom witness-program script (legacy scripts are
+   * rejected). `script_pubkey_hex` (the funding scriptPubKey) sizes the
+   * fan-out output and dust; `signed_input_weight` (weight units) is an upper
+   * bound on the input's signed weight, so the quote stays exact or slightly
+   * conservative.
+   */
+  class Custom_ extends UniffiEnum implements Custom__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'CpfpFundingKind';
+    readonly tag = CpfpFundingKind_Tags.Custom;
+    readonly inner: Readonly<{
+      scriptPubkeyHex: string;
+      signedInputWeight: /*u64*/ bigint;
+    }>;
+    constructor(inner: {
+      scriptPubkeyHex: string;
+      signedInputWeight: /*u64*/ bigint;
+    }) {
+      super('CpfpFundingKind', 'Custom');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      scriptPubkeyHex: string;
+      signedInputWeight: /*u64*/ bigint;
+    }): Custom_ {
+      return new Custom_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Custom_ {
+      return obj.tag === CpfpFundingKind_Tags.Custom;
+    }
+  }
+
+  function instanceOf(obj: any): obj is CpfpFundingKind {
+    return obj[uniffiTypeNameSymbol] === 'CpfpFundingKind';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    P2wpkh: P2wpkh_,
+    P2tr: P2tr_,
+    Custom: Custom_,
+  });
+})();
+
+/**
+ * The kind of UTXO that will fund an exit's fees.
+ */
+
+export type CpfpFundingKind = InstanceType<
+  (typeof CpfpFundingKind)[keyof Omit<typeof CpfpFundingKind, 'instanceOf'>]
+>;
+
+// FfiConverter for enum CpfpFundingKind
+const FfiConverterTypeCpfpFundingKind = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = CpfpFundingKind;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new CpfpFundingKind.P2wpkh();
+        case 2:
+          return new CpfpFundingKind.P2tr();
+        case 3:
+          return new CpfpFundingKind.Custom({
+            scriptPubkeyHex: FfiConverterString.read(from),
+            signedInputWeight: FfiConverterUInt64.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case CpfpFundingKind_Tags.P2wpkh: {
+          ordinalConverter.write(1, into);
+          return;
+        }
+        case CpfpFundingKind_Tags.P2tr: {
+          ordinalConverter.write(2, into);
+          return;
+        }
+        case CpfpFundingKind_Tags.Custom: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.scriptPubkeyHex, into);
+          FfiConverterUInt64.write(inner.signedInputWeight, into);
+          return;
+        }
+        default:
+          // Throwing from here means that CpfpFundingKind_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case CpfpFundingKind_Tags.P2wpkh: {
+          return ordinalConverter.allocationSize(1);
+        }
+        case CpfpFundingKind_Tags.P2tr: {
+          return ordinalConverter.allocationSize(2);
+        }
+        case CpfpFundingKind_Tags.Custom: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner.scriptPubkeyHex);
+          size += FfiConverterUInt64.allocationSize(inner.signedInputWeight);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Enum: CpfpInput
+export enum CpfpInput_Tags {
+  P2wpkh = 'P2wpkh',
+  P2tr = 'P2tr',
+  Custom = 'Custom',
+}
+/**
+ * A funding UTXO that pays the on-chain fees of a unilateral exit.
+ */
+export const CpfpInput = (() => {
+  type P2wpkh__interface = {
+    tag: CpfpInput_Tags.P2wpkh;
+    inner: Readonly<{
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      pubkey: string;
+    }>;
+  };
+
+  /**
+   * A P2WPKH (native segwit v0) UTXO controlled by `pubkey` (33-byte
+   * compressed, hex).
+   */
+  class P2wpkh_ extends UniffiEnum implements P2wpkh__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'CpfpInput';
+    readonly tag = CpfpInput_Tags.P2wpkh;
+    readonly inner: Readonly<{
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      pubkey: string;
+    }>;
+    constructor(inner: {
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      pubkey: string;
+    }) {
+      super('CpfpInput', 'P2wpkh');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      pubkey: string;
+    }): P2wpkh_ {
+      return new P2wpkh_(inner);
+    }
+
+    static instanceOf(obj: any): obj is P2wpkh_ {
+      return obj.tag === CpfpInput_Tags.P2wpkh;
+    }
+  }
+
+  type P2tr__interface = {
+    tag: CpfpInput_Tags.P2tr;
+    inner: Readonly<{
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      pubkey: string;
+    }>;
+  };
+
+  /**
+   * A P2TR (taproot, key-path) UTXO. `pubkey` (x-only or compressed, hex) is
+   * the **internal** (untweaked, BIP86 key-path) public key whose secret signs
+   * the input, not the tweaked on-chain output key. The SDK applies the BIP86
+   * taproot tweak itself to derive the funding scriptPubKey, so passing the
+   * already-tweaked output key here produces a scriptPubKey that does not match
+   * the UTXO and the built transaction is rejected at broadcast.
+   */
+  class P2tr_ extends UniffiEnum implements P2tr__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'CpfpInput';
+    readonly tag = CpfpInput_Tags.P2tr;
+    readonly inner: Readonly<{
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      pubkey: string;
+    }>;
+    constructor(inner: {
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      pubkey: string;
+    }) {
+      super('CpfpInput', 'P2tr');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      pubkey: string;
+    }): P2tr_ {
+      return new P2tr_(inner);
+    }
+
+    static instanceOf(obj: any): obj is P2tr_ {
+      return obj.tag === CpfpInput_Tags.P2tr;
+    }
+  }
+
+  type Custom__interface = {
+    tag: CpfpInput_Tags.Custom;
+    inner: Readonly<{
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      scriptPubkeyHex: string;
+      signedInputWeight: /*u64*/ bigint;
+    }>;
+  };
+
+  /**
+   * Any witness-program script, signed via a custom `CpfpSigner`. Legacy
+   * (non-SegWit) scripts are rejected. `signed_input_weight` (weight units)
+   * is an upper bound on the input's signed weight, so the fee stays exact,
+   * or slightly conservative if the real signature is shorter.
+   */
+  class Custom_ extends UniffiEnum implements Custom__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'CpfpInput';
+    readonly tag = CpfpInput_Tags.Custom;
+    readonly inner: Readonly<{
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      scriptPubkeyHex: string;
+      signedInputWeight: /*u64*/ bigint;
+    }>;
+    constructor(inner: {
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      scriptPubkeyHex: string;
+      signedInputWeight: /*u64*/ bigint;
+    }) {
+      super('CpfpInput', 'Custom');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      txid: string;
+      vout: /*u32*/ number;
+      value: /*u64*/ bigint;
+      scriptPubkeyHex: string;
+      signedInputWeight: /*u64*/ bigint;
+    }): Custom_ {
+      return new Custom_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Custom_ {
+      return obj.tag === CpfpInput_Tags.Custom;
+    }
+  }
+
+  function instanceOf(obj: any): obj is CpfpInput {
+    return obj[uniffiTypeNameSymbol] === 'CpfpInput';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    P2wpkh: P2wpkh_,
+    P2tr: P2tr_,
+    Custom: Custom_,
+  });
+})();
+
+/**
+ * A funding UTXO that pays the on-chain fees of a unilateral exit.
+ */
+
+export type CpfpInput = InstanceType<
+  (typeof CpfpInput)[keyof Omit<typeof CpfpInput, 'instanceOf'>]
+>;
+
+// FfiConverter for enum CpfpInput
+const FfiConverterTypeCpfpInput = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = CpfpInput;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new CpfpInput.P2wpkh({
+            txid: FfiConverterString.read(from),
+            vout: FfiConverterUInt32.read(from),
+            value: FfiConverterUInt64.read(from),
+            pubkey: FfiConverterString.read(from),
+          });
+        case 2:
+          return new CpfpInput.P2tr({
+            txid: FfiConverterString.read(from),
+            vout: FfiConverterUInt32.read(from),
+            value: FfiConverterUInt64.read(from),
+            pubkey: FfiConverterString.read(from),
+          });
+        case 3:
+          return new CpfpInput.Custom({
+            txid: FfiConverterString.read(from),
+            vout: FfiConverterUInt32.read(from),
+            value: FfiConverterUInt64.read(from),
+            scriptPubkeyHex: FfiConverterString.read(from),
+            signedInputWeight: FfiConverterUInt64.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case CpfpInput_Tags.P2wpkh: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.txid, into);
+          FfiConverterUInt32.write(inner.vout, into);
+          FfiConverterUInt64.write(inner.value, into);
+          FfiConverterString.write(inner.pubkey, into);
+          return;
+        }
+        case CpfpInput_Tags.P2tr: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.txid, into);
+          FfiConverterUInt32.write(inner.vout, into);
+          FfiConverterUInt64.write(inner.value, into);
+          FfiConverterString.write(inner.pubkey, into);
+          return;
+        }
+        case CpfpInput_Tags.Custom: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.txid, into);
+          FfiConverterUInt32.write(inner.vout, into);
+          FfiConverterUInt64.write(inner.value, into);
+          FfiConverterString.write(inner.scriptPubkeyHex, into);
+          FfiConverterUInt64.write(inner.signedInputWeight, into);
+          return;
+        }
+        default:
+          // Throwing from here means that CpfpInput_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case CpfpInput_Tags.P2wpkh: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.txid);
+          size += FfiConverterUInt32.allocationSize(inner.vout);
+          size += FfiConverterUInt64.allocationSize(inner.value);
+          size += FfiConverterString.allocationSize(inner.pubkey);
+          return size;
+        }
+        case CpfpInput_Tags.P2tr: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterString.allocationSize(inner.txid);
+          size += FfiConverterUInt32.allocationSize(inner.vout);
+          size += FfiConverterUInt64.allocationSize(inner.value);
+          size += FfiConverterString.allocationSize(inner.pubkey);
+          return size;
+        }
+        case CpfpInput_Tags.Custom: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner.txid);
+          size += FfiConverterUInt32.allocationSize(inner.vout);
+          size += FfiConverterUInt64.allocationSize(inner.value);
+          size += FfiConverterString.allocationSize(inner.scriptPubkeyHex);
+          size += FfiConverterUInt64.allocationSize(inner.signedInputWeight);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
 export enum CrossChainAddressFamily {
   Evm,
   Solana,
@@ -20187,6 +22189,149 @@ const FfiConverterTypeErrorKind = (() => {
   return new FFIConverter();
 })();
 
+// Enum: ExitLeafSelection
+export enum ExitLeafSelection_Tags {
+  Auto = 'Auto',
+  Specific = 'Specific',
+}
+/**
+ * Which leaves to exit.
+ */
+export const ExitLeafSelection = (() => {
+  type Auto__interface = {
+    tag: ExitLeafSelection_Tags.Auto;
+  };
+
+  /**
+   * Exit every leaf whose value exceeds its own marginal exit cost (its tree
+   * and refund CPFP fees plus its sweep input). This per-leaf test does not
+   * include the shared fan-out fee, so funding many leaves from a single UTXO
+   * adds `fanout_fee_sat` on top: compare `recoverable_value_sat` with
+   * `total_fee_sat`, or fund one UTXO per branch to avoid the fan-out. Leaves
+   * that fail the per-leaf test are skipped.
+   */
+  class Auto_ extends UniffiEnum implements Auto__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ExitLeafSelection';
+    readonly tag = ExitLeafSelection_Tags.Auto;
+    constructor() {
+      super('ExitLeafSelection', 'Auto');
+    }
+
+    static new(): Auto_ {
+      return new Auto_();
+    }
+
+    static instanceOf(obj: any): obj is Auto_ {
+      return obj.tag === ExitLeafSelection_Tags.Auto;
+    }
+  }
+
+  type Specific__interface = {
+    tag: ExitLeafSelection_Tags.Specific;
+    inner: Readonly<{ leafIds: Array<string> }>;
+  };
+
+  /**
+   * Exit exactly these leaves, regardless of profitability.
+   */
+  class Specific_ extends UniffiEnum implements Specific__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ExitLeafSelection';
+    readonly tag = ExitLeafSelection_Tags.Specific;
+    readonly inner: Readonly<{ leafIds: Array<string> }>;
+    constructor(inner: { leafIds: Array<string> }) {
+      super('ExitLeafSelection', 'Specific');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { leafIds: Array<string> }): Specific_ {
+      return new Specific_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Specific_ {
+      return obj.tag === ExitLeafSelection_Tags.Specific;
+    }
+  }
+
+  function instanceOf(obj: any): obj is ExitLeafSelection {
+    return obj[uniffiTypeNameSymbol] === 'ExitLeafSelection';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    Auto: Auto_,
+    Specific: Specific_,
+  });
+})();
+
+/**
+ * Which leaves to exit.
+ */
+
+export type ExitLeafSelection = InstanceType<
+  (typeof ExitLeafSelection)[keyof Omit<typeof ExitLeafSelection, 'instanceOf'>]
+>;
+
+// FfiConverter for enum ExitLeafSelection
+const FfiConverterTypeExitLeafSelection = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = ExitLeafSelection;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new ExitLeafSelection.Auto();
+        case 2:
+          return new ExitLeafSelection.Specific({
+            leafIds: FfiConverterArrayString.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case ExitLeafSelection_Tags.Auto: {
+          ordinalConverter.write(1, into);
+          return;
+        }
+        case ExitLeafSelection_Tags.Specific: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterArrayString.write(inner.leafIds, into);
+          return;
+        }
+        default:
+          // Throwing from here means that ExitLeafSelection_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case ExitLeafSelection_Tags.Auto: {
+          return ordinalConverter.allocationSize(1);
+        }
+        case ExitLeafSelection_Tags.Specific: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterArrayString.allocationSize(inner.leafIds);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
 // Enum: ExternalFrostDerivation
 export enum ExternalFrostDerivation_Tags {
   SigningLeaf = 'SigningLeaf',
@@ -22060,6 +24205,160 @@ const FfiConverterTypeOptimizationOutcome = (() => {
   return new FFIConverter();
 })();
 
+// Enum: Outspend
+export enum Outspend_Tags {
+  Unspent = 'Unspent',
+  Spent = 'Spent',
+}
+/**
+ * The spend status of a transaction output.
+ */
+export const Outspend = (() => {
+  type Unspent__interface = {
+    tag: Outspend_Tags.Unspent;
+  };
+
+  class Unspent_ extends UniffiEnum implements Unspent__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'Outspend';
+    readonly tag = Outspend_Tags.Unspent;
+    constructor() {
+      super('Outspend', 'Unspent');
+    }
+
+    static new(): Unspent_ {
+      return new Unspent_();
+    }
+
+    static instanceOf(obj: any): obj is Unspent_ {
+      return obj.tag === Outspend_Tags.Unspent;
+    }
+  }
+
+  type Spent__interface = {
+    tag: Outspend_Tags.Spent;
+    inner: Readonly<{ txid: string; vin: /*u32*/ number; status: TxStatus }>;
+  };
+
+  /**
+   * The output is spent by input `vin` of transaction `txid`; `status` is
+   * that spending transaction's confirmation status.
+   */
+  class Spent_ extends UniffiEnum implements Spent__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'Outspend';
+    readonly tag = Outspend_Tags.Spent;
+    readonly inner: Readonly<{
+      txid: string;
+      vin: /*u32*/ number;
+      status: TxStatus;
+    }>;
+    constructor(inner: {
+      txid: string;
+      vin: /*u32*/ number;
+      status: TxStatus;
+    }) {
+      super('Outspend', 'Spent');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      txid: string;
+      vin: /*u32*/ number;
+      status: TxStatus;
+    }): Spent_ {
+      return new Spent_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Spent_ {
+      return obj.tag === Outspend_Tags.Spent;
+    }
+  }
+
+  function instanceOf(obj: any): obj is Outspend {
+    return obj[uniffiTypeNameSymbol] === 'Outspend';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    Unspent: Unspent_,
+    Spent: Spent_,
+  });
+})();
+
+/**
+ * The spend status of a transaction output.
+ */
+
+export type Outspend = InstanceType<
+  (typeof Outspend)[keyof Omit<typeof Outspend, 'instanceOf'>]
+>;
+
+// FfiConverter for enum Outspend
+const FfiConverterTypeOutspend = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = Outspend;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new Outspend.Unspent();
+        case 2:
+          return new Outspend.Spent({
+            txid: FfiConverterString.read(from),
+            vin: FfiConverterUInt32.read(from),
+            status: FfiConverterTypeTxStatus.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case Outspend_Tags.Unspent: {
+          ordinalConverter.write(1, into);
+          return;
+        }
+        case Outspend_Tags.Spent: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.txid, into);
+          FfiConverterUInt32.write(inner.vin, into);
+          FfiConverterTypeTxStatus.write(inner.status, into);
+          return;
+        }
+        default:
+          // Throwing from here means that Outspend_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case Outspend_Tags.Unspent: {
+          return ordinalConverter.allocationSize(1);
+        }
+        case Outspend_Tags.Spent: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterString.allocationSize(inner.txid);
+          size += FfiConverterUInt32.allocationSize(inner.vin);
+          size += FfiConverterTypeTxStatus.allocationSize(inner.status);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
 // Enum: PasskeyAvailability
 export enum PasskeyAvailability_Tags {
   Available = 'Available',
@@ -22318,6 +24617,7 @@ export enum PasskeyError_Tags {
   InvalidPrfOutput = 'InvalidPrfOutput',
   MnemonicError = 'MnemonicError',
   InvalidSalt = 'InvalidSalt',
+  CreatedButNotDerived = 'CreatedButNotDerived',
   Generic = 'Generic',
 }
 /**
@@ -22625,6 +24925,66 @@ export const PasskeyError = (() => {
     }
   }
 
+  type CreatedButNotDerived__interface = {
+    tag: PasskeyError_Tags.CreatedButNotDerived;
+    inner: Readonly<{ credentialId: ArrayBuffer; source: PrfProviderError }>;
+  };
+
+  /**
+   * Registration created the credential, then the derive that
+   * followed it failed. The passkey exists on the device: recover by
+   * signing in pinned to `credential_id`. Registering again would
+   * leave this one behind, owning a wallet nothing points to.
+   *
+   * Only wraps a [`PrfProviderError`], so hosts unwrap once and keep
+   * the arms they already have. Failures that are not the
+   * authenticator's (mnemonic, key derivation, invalid PRF output)
+   * propagate as their own variant, unwrapped.
+   */
+  class CreatedButNotDerived_
+    extends UniffiError
+    implements CreatedButNotDerived__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'PasskeyError';
+    readonly tag = PasskeyError_Tags.CreatedButNotDerived;
+    readonly inner: Readonly<{
+      credentialId: ArrayBuffer;
+      source: PrfProviderError;
+    }>;
+    constructor(inner: {
+      credentialId: ArrayBuffer;
+      source: PrfProviderError;
+    }) {
+      super('PasskeyError', 'CreatedButNotDerived');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      credentialId: ArrayBuffer;
+      source: PrfProviderError;
+    }): CreatedButNotDerived_ {
+      return new CreatedButNotDerived_(inner);
+    }
+
+    static instanceOf(obj: any): obj is CreatedButNotDerived_ {
+      return obj.tag === PasskeyError_Tags.CreatedButNotDerived;
+    }
+
+    static hasInner(obj: any): obj is CreatedButNotDerived_ {
+      return CreatedButNotDerived_.instanceOf(obj);
+    }
+
+    static getInner(
+      obj: CreatedButNotDerived_
+    ): Readonly<{ credentialId: ArrayBuffer; source: PrfProviderError }> {
+      return obj.inner;
+    }
+  }
+
   type Generic__interface = {
     tag: PasskeyError_Tags.Generic;
     inner: Readonly<[string]>;
@@ -22674,6 +25034,7 @@ export const PasskeyError = (() => {
     InvalidPrfOutput: InvalidPrfOutput_,
     MnemonicError: MnemonicError_,
     InvalidSalt: InvalidSalt_,
+    CreatedButNotDerived: CreatedButNotDerived_,
     Generic: Generic_,
   });
 })();
@@ -22722,6 +25083,11 @@ const FfiConverterTypePasskeyError = (() => {
         case 8:
           return new PasskeyError.InvalidSalt(FfiConverterString.read(from));
         case 9:
+          return new PasskeyError.CreatedButNotDerived({
+            credentialId: FfiConverterArrayBuffer.read(from),
+            source: FfiConverterTypePrfProviderError.read(from),
+          });
+        case 10:
           return new PasskeyError.Generic(FfiConverterString.read(from));
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
@@ -22777,9 +25143,16 @@ const FfiConverterTypePasskeyError = (() => {
           FfiConverterString.write(inner[0], into);
           return;
         }
-        case PasskeyError_Tags.Generic: {
+        case PasskeyError_Tags.CreatedButNotDerived: {
           ordinalConverter.write(9, into);
           const inner = value.inner;
+          FfiConverterArrayBuffer.write(inner.credentialId, into);
+          FfiConverterTypePrfProviderError.write(inner.source, into);
+          return;
+        }
+        case PasskeyError_Tags.Generic: {
+          ordinalConverter.write(10, into);
+          const inner = value.inner;
           FfiConverterString.write(inner[0], into);
           return;
         }
@@ -22838,9 +25211,16 @@ const FfiConverterTypePasskeyError = (() => {
           size += FfiConverterString.allocationSize(inner[0]);
           return size;
         }
-        case PasskeyError_Tags.Generic: {
+        case PasskeyError_Tags.CreatedButNotDerived: {
           const inner = value.inner;
           let size = ordinalConverter.allocationSize(9);
+          size += FfiConverterArrayBuffer.allocationSize(inner.credentialId);
+          size += FfiConverterTypePrfProviderError.allocationSize(inner.source);
+          return size;
+        }
+        case PasskeyError_Tags.Generic: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(10);
           size += FfiConverterString.allocationSize(inner[0]);
           return size;
         }
@@ -25060,6 +27440,7 @@ const FfiConverterTypePublishSignedLnurlPayResponse = (() => {
 export enum PublishSignedTransferPackageResponse_Tags {
   SwapCompleted = 'SwapCompleted',
   PaymentSent = 'PaymentSent',
+  PaymentsSent = 'PaymentsSent',
 }
 export const PublishSignedTransferPackageResponse = (() => {
   type SwapCompleted__interface = {
@@ -25115,6 +27496,37 @@ export const PublishSignedTransferPackageResponse = (() => {
     }
   }
 
+  type PaymentsSent__interface = {
+    tag: PublishSignedTransferPackageResponse_Tags.PaymentsSent;
+    inner: Readonly<{ payments: Array<Payment> }>;
+  };
+
+  /**
+   * Returned for a batch package: one payment per recipient, in recipient
+   * order.
+   */
+  class PaymentsSent_ extends UniffiEnum implements PaymentsSent__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'PublishSignedTransferPackageResponse';
+    readonly tag = PublishSignedTransferPackageResponse_Tags.PaymentsSent;
+    readonly inner: Readonly<{ payments: Array<Payment> }>;
+    constructor(inner: { payments: Array<Payment> }) {
+      super('PublishSignedTransferPackageResponse', 'PaymentsSent');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { payments: Array<Payment> }): PaymentsSent_ {
+      return new PaymentsSent_(inner);
+    }
+
+    static instanceOf(obj: any): obj is PaymentsSent_ {
+      return obj.tag === PublishSignedTransferPackageResponse_Tags.PaymentsSent;
+    }
+  }
+
   function instanceOf(obj: any): obj is PublishSignedTransferPackageResponse {
     return obj[uniffiTypeNameSymbol] === 'PublishSignedTransferPackageResponse';
   }
@@ -25123,6 +27535,7 @@ export const PublishSignedTransferPackageResponse = (() => {
     instanceOf,
     SwapCompleted: SwapCompleted_,
     PaymentSent: PaymentSent_,
+    PaymentsSent: PaymentsSent_,
   });
 })();
 
@@ -25146,6 +27559,10 @@ const FfiConverterTypePublishSignedTransferPackageResponse = (() => {
           return new PublishSignedTransferPackageResponse.PaymentSent({
             payment: FfiConverterTypePayment.read(from),
           });
+        case 3:
+          return new PublishSignedTransferPackageResponse.PaymentsSent({
+            payments: FfiConverterArrayTypePayment.read(from),
+          });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
@@ -25162,6 +27579,12 @@ const FfiConverterTypePublishSignedTransferPackageResponse = (() => {
           FfiConverterTypePayment.write(inner.payment, into);
           return;
         }
+        case PublishSignedTransferPackageResponse_Tags.PaymentsSent: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterArrayTypePayment.write(inner.payments, into);
+          return;
+        }
         default:
           // Throwing from here means that PublishSignedTransferPackageResponse_Tags hasn't matched an ordinal.
           throw new UniffiInternalError.UnexpectedEnumCase();
@@ -25178,6 +27601,12 @@ const FfiConverterTypePublishSignedTransferPackageResponse = (() => {
           size += FfiConverterTypePayment.allocationSize(inner.payment);
           return size;
         }
+        case PublishSignedTransferPackageResponse_Tags.PaymentsSent: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterArrayTypePayment.allocationSize(inner.payments);
+          return size;
+        }
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
@@ -25539,6 +27968,8 @@ export enum SdkError_Tags {
   Signer = 'Signer',
   OptimizationAlreadyRunning = 'OptimizationAlreadyRunning',
   OptimizationCancelled = 'OptimizationCancelled',
+  InsufficientCpfpFunds = 'InsufficientCpfpFunds',
+  FundingUtxoConflict = 'FundingUtxoConflict',
   Generic = 'Generic',
 }
 /**
@@ -25582,6 +28013,7 @@ export const SdkError = (() => {
 
   type InsufficientFunds__interface = {
     tag: SdkError_Tags.InsufficientFunds;
+    inner: Readonly<{ tokenIdentifier: string | undefined }>;
   };
 
   class InsufficientFunds_
@@ -25594,12 +28026,24 @@ export const SdkError = (() => {
      */
     readonly [uniffiTypeNameSymbol] = 'SdkError';
     readonly tag = SdkError_Tags.InsufficientFunds;
-    constructor() {
+    readonly inner: Readonly<{ tokenIdentifier: string | undefined }>;
+    constructor(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;
+    }) {
       super('SdkError', 'InsufficientFunds');
+      this.inner = Object.freeze(inner);
     }
 
-    static new(): InsufficientFunds_ {
-      return new InsufficientFunds_();
+    static 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;
+    }): InsufficientFunds_ {
+      return new InsufficientFunds_(inner);
     }
 
     static instanceOf(obj: any): obj is InsufficientFunds_ {
@@ -25607,7 +28051,13 @@ export const SdkError = (() => {
     }
 
     static hasInner(obj: any): obj is InsufficientFunds_ {
-      return false;
+      return InsufficientFunds_.instanceOf(obj);
+    }
+
+    static getInner(
+      obj: InsufficientFunds_
+    ): Readonly<{ tokenIdentifier: string | undefined }> {
+      return obj.inner;
     }
   }
 
@@ -26045,6 +28495,96 @@ export const SdkError = (() => {
     }
   }
 
+  type InsufficientCpfpFunds__interface = {
+    tag: SdkError_Tags.InsufficientCpfpFunds;
+    inner: Readonly<{ requiredSat: /*u64*/ bigint }>;
+  };
+
+  /**
+   * The provided CPFP funding is too low to cover the exit's on-chain fees.
+   */
+  class InsufficientCpfpFunds_
+    extends UniffiError
+    implements InsufficientCpfpFunds__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'SdkError';
+    readonly tag = SdkError_Tags.InsufficientCpfpFunds;
+    readonly inner: Readonly<{ requiredSat: /*u64*/ bigint }>;
+    constructor(inner: { requiredSat: /*u64*/ bigint }) {
+      super('SdkError', 'InsufficientCpfpFunds');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { requiredSat: /*u64*/ bigint }): InsufficientCpfpFunds_ {
+      return new InsufficientCpfpFunds_(inner);
+    }
+
+    static instanceOf(obj: any): obj is InsufficientCpfpFunds_ {
+      return obj.tag === SdkError_Tags.InsufficientCpfpFunds;
+    }
+
+    static hasInner(obj: any): obj is InsufficientCpfpFunds_ {
+      return InsufficientCpfpFunds_.instanceOf(obj);
+    }
+
+    static getInner(
+      obj: InsufficientCpfpFunds_
+    ): Readonly<{ requiredSat: /*u64*/ bigint }> {
+      return obj.inner;
+    }
+  }
+
+  type FundingUtxoConflict__interface = {
+    tag: SdkError_Tags.FundingUtxoConflict;
+    inner: Readonly<{ txid: string; vout: /*u32*/ number }>;
+  };
+
+  /**
+   * A provided funding UTXO was already spent on-chain by a transaction that
+   * is not the expected fan-out, so it cannot fund this exit.
+   */
+  class FundingUtxoConflict_
+    extends UniffiError
+    implements FundingUtxoConflict__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'SdkError';
+    readonly tag = SdkError_Tags.FundingUtxoConflict;
+    readonly inner: Readonly<{ txid: string; vout: /*u32*/ number }>;
+    constructor(inner: { txid: string; vout: /*u32*/ number }) {
+      super('SdkError', 'FundingUtxoConflict');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      txid: string;
+      vout: /*u32*/ number;
+    }): FundingUtxoConflict_ {
+      return new FundingUtxoConflict_(inner);
+    }
+
+    static instanceOf(obj: any): obj is FundingUtxoConflict_ {
+      return obj.tag === SdkError_Tags.FundingUtxoConflict;
+    }
+
+    static hasInner(obj: any): obj is FundingUtxoConflict_ {
+      return FundingUtxoConflict_.instanceOf(obj);
+    }
+
+    static getInner(
+      obj: FundingUtxoConflict_
+    ): Readonly<{ txid: string; vout: /*u32*/ number }> {
+      return obj.inner;
+    }
+  }
+
   type Generic__interface = {
     tag: SdkError_Tags.Generic;
     inner: Readonly<[string]>;
@@ -26099,6 +28639,8 @@ export const SdkError = (() => {
     Signer: Signer_,
     OptimizationAlreadyRunning: OptimizationAlreadyRunning_,
     OptimizationCancelled: OptimizationCancelled_,
+    InsufficientCpfpFunds: InsufficientCpfpFunds_,
+    FundingUtxoConflict: FundingUtxoConflict_,
     Generic: Generic_,
   });
 })();
@@ -26121,7 +28663,9 @@ const FfiConverterTypeSdkError = (() => {
         case 1:
           return new SdkError.SparkError(FfiConverterString.read(from));
         case 2:
-          return new SdkError.InsufficientFunds();
+          return new SdkError.InsufficientFunds({
+            tokenIdentifier: FfiConverterOptionalString.read(from),
+          });
         case 3:
           return new SdkError.InvalidUuid(FfiConverterString.read(from));
         case 4:
@@ -26154,6 +28698,15 @@ const FfiConverterTypeSdkError = (() => {
         case 13:
           return new SdkError.OptimizationCancelled();
         case 14:
+          return new SdkError.InsufficientCpfpFunds({
+            requiredSat: FfiConverterUInt64.read(from),
+          });
+        case 15:
+          return new SdkError.FundingUtxoConflict({
+            txid: FfiConverterString.read(from),
+            vout: FfiConverterUInt32.read(from),
+          });
+        case 16:
           return new SdkError.Generic(FfiConverterString.read(from));
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
@@ -26169,6 +28722,8 @@ const FfiConverterTypeSdkError = (() => {
         }
         case SdkError_Tags.InsufficientFunds: {
           ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterOptionalString.write(inner.tokenIdentifier, into);
           return;
         }
         case SdkError_Tags.InvalidUuid: {
@@ -26238,9 +28793,22 @@ const FfiConverterTypeSdkError = (() => {
           ordinalConverter.write(13, into);
           return;
         }
-        case SdkError_Tags.Generic: {
+        case SdkError_Tags.InsufficientCpfpFunds: {
           ordinalConverter.write(14, into);
           const inner = value.inner;
+          FfiConverterUInt64.write(inner.requiredSat, into);
+          return;
+        }
+        case SdkError_Tags.FundingUtxoConflict: {
+          ordinalConverter.write(15, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.txid, into);
+          FfiConverterUInt32.write(inner.vout, into);
+          return;
+        }
+        case SdkError_Tags.Generic: {
+          ordinalConverter.write(16, into);
+          const inner = value.inner;
           FfiConverterString.write(inner[0], into);
           return;
         }
@@ -26258,7 +28826,12 @@ const FfiConverterTypeSdkError = (() => {
           return size;
         }
         case SdkError_Tags.InsufficientFunds: {
-          return ordinalConverter.allocationSize(2);
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterOptionalString.allocationSize(
+            inner.tokenIdentifier
+          );
+          return size;
         }
         case SdkError_Tags.InvalidUuid: {
           const inner = value.inner;
@@ -26327,9 +28900,22 @@ const FfiConverterTypeSdkError = (() => {
         case SdkError_Tags.OptimizationCancelled: {
           return ordinalConverter.allocationSize(13);
         }
-        case SdkError_Tags.Generic: {
+        case SdkError_Tags.InsufficientCpfpFunds: {
           const inner = value.inner;
           let size = ordinalConverter.allocationSize(14);
+          size += FfiConverterUInt64.allocationSize(inner.requiredSat);
+          return size;
+        }
+        case SdkError_Tags.FundingUtxoConflict: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(15);
+          size += FfiConverterString.allocationSize(inner.txid);
+          size += FfiConverterUInt32.allocationSize(inner.vout);
+          return size;
+        }
+        case SdkError_Tags.Generic: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(16);
           size += FfiConverterString.allocationSize(inner[0]);
           return size;
         }
@@ -29266,6 +31852,150 @@ const FfiConverterTypeSparkHtlcStatus = (() => {
   return new FFIConverter();
 })();
 
+// Enum: SparkMasterIdentityPublicKey
+export enum SparkMasterIdentityPublicKey_Tags {
+  Set = 'Set',
+  Unset = 'Unset',
+}
+/**
+ * Specifies how to update the wallet's Spark master identity public key.
+ */
+export const SparkMasterIdentityPublicKey = (() => {
+  type Set__interface = {
+    tag: SparkMasterIdentityPublicKey_Tags.Set;
+    inner: Readonly<{ publicKey: string }>;
+  };
+
+  /**
+   * Designate the holder of this public key as the wallet's master
+   * identity, replacing any previously designated key. Must be hex encoded
+   * in the 33-byte compressed form.
+   */
+  class Set_ extends UniffiEnum implements Set__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'SparkMasterIdentityPublicKey';
+    readonly tag = SparkMasterIdentityPublicKey_Tags.Set;
+    readonly inner: Readonly<{ publicKey: string }>;
+    constructor(inner: { publicKey: string }) {
+      super('SparkMasterIdentityPublicKey', 'Set');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { publicKey: string }): Set_ {
+      return new Set_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Set_ {
+      return obj.tag === SparkMasterIdentityPublicKey_Tags.Set;
+    }
+  }
+
+  type Unset__interface = {
+    tag: SparkMasterIdentityPublicKey_Tags.Unset;
+  };
+
+  /**
+   * Remove the designated master identity, leaving the owner as the only
+   * party able to read the wallet under private mode.
+   */
+  class Unset_ extends UniffiEnum implements Unset__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'SparkMasterIdentityPublicKey';
+    readonly tag = SparkMasterIdentityPublicKey_Tags.Unset;
+    constructor() {
+      super('SparkMasterIdentityPublicKey', 'Unset');
+    }
+
+    static new(): Unset_ {
+      return new Unset_();
+    }
+
+    static instanceOf(obj: any): obj is Unset_ {
+      return obj.tag === SparkMasterIdentityPublicKey_Tags.Unset;
+    }
+  }
+
+  function instanceOf(obj: any): obj is SparkMasterIdentityPublicKey {
+    return obj[uniffiTypeNameSymbol] === 'SparkMasterIdentityPublicKey';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    Set: Set_,
+    Unset: Unset_,
+  });
+})();
+
+/**
+ * Specifies how to update the wallet's Spark master identity public key.
+ */
+
+export type SparkMasterIdentityPublicKey = InstanceType<
+  (typeof SparkMasterIdentityPublicKey)[keyof Omit<
+    typeof SparkMasterIdentityPublicKey,
+    'instanceOf'
+  >]
+>;
+
+// FfiConverter for enum SparkMasterIdentityPublicKey
+const FfiConverterTypeSparkMasterIdentityPublicKey = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = SparkMasterIdentityPublicKey;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new SparkMasterIdentityPublicKey.Set({
+            publicKey: FfiConverterString.read(from),
+          });
+        case 2:
+          return new SparkMasterIdentityPublicKey.Unset();
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case SparkMasterIdentityPublicKey_Tags.Set: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.publicKey, into);
+          return;
+        }
+        case SparkMasterIdentityPublicKey_Tags.Unset: {
+          ordinalConverter.write(2, into);
+          return;
+        }
+        default:
+          // Throwing from here means that SparkMasterIdentityPublicKey_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case SparkMasterIdentityPublicKey_Tags.Set: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.publicKey);
+          return size;
+        }
+        case SparkMasterIdentityPublicKey_Tags.Unset: {
+          return ordinalConverter.allocationSize(2);
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
 // Enum: StableBalanceActiveLabel
 export enum StableBalanceActiveLabel_Tags {
   Set = 'Set',
@@ -30847,11 +33577,72 @@ const FfiConverterTypeTransferTarget = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * The role of a transaction in the exit path.
+ */
+export enum UnilateralExitTxKind {
+  /**
+   * Splits the caller's funding into one output per branch. Present only
+   * when the funding couldn't be matched one-to-one to branches.
+   */
+  FanOut,
+  /**
+   * A tree node transaction (root, intermediate, or leaf node).
+   */
+  Node,
+  /**
+   * A leaf's refund transaction.
+   */
+  Refund,
+  /**
+   * The final transaction sweeping all refund outputs to the destination.
+   */
+  Sweep,
+}
+
+const FfiConverterTypeUnilateralExitTxKind = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = UnilateralExitTxKind;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return UnilateralExitTxKind.FanOut;
+        case 2:
+          return UnilateralExitTxKind.Node;
+        case 3:
+          return UnilateralExitTxKind.Refund;
+        case 4:
+          return UnilateralExitTxKind.Sweep;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case UnilateralExitTxKind.FanOut:
+          return ordinalConverter.write(1, into);
+        case UnilateralExitTxKind.Node:
+          return ordinalConverter.write(2, into);
+        case UnilateralExitTxKind.Refund:
+          return ordinalConverter.write(3, into);
+        case UnilateralExitTxKind.Sweep:
+          return ordinalConverter.write(4, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
 // Enum: UnsignedTransferPackage
 export enum UnsignedTransferPackage_Tags {
   Swap = 'Swap',
   Transfer = 'Transfer',
   Token = 'Token',
+  TokenBatch = 'TokenBatch',
 }
 export const UnsignedTransferPackage = (() => {
   type Swap__interface = {
@@ -31011,6 +33802,71 @@ export const UnsignedTransferPackage = (() => {
     }
   }
 
+  type TokenBatch__interface = {
+    tag: UnsignedTransferPackage_Tags.TokenBatch;
+    inner: Readonly<{
+      prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+      tokenContext: ArrayBuffer;
+      totals: Array<BatchTotal>;
+      isSwap: boolean;
+    }>;
+  };
+
+  /**
+   * One token transaction paying several recipients. Publishing it returns
+   * `PaymentsSent` with one payment per recipient.
+   */
+  class TokenBatch_ extends UniffiEnum implements TokenBatch__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'UnsignedTransferPackage';
+    readonly tag = UnsignedTransferPackage_Tags.TokenBatch;
+    readonly inner: Readonly<{
+      prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+      tokenContext: ArrayBuffer;
+      totals: Array<BatchTotal>;
+      isSwap: boolean;
+    }>;
+    constructor(inner: {
+      prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+      tokenContext: ArrayBuffer;
+      /**
+       * What the batch debits, per token. A batch spanning tokens has no
+       * single amount to report.
+       */ totals: Array<BatchTotal>;
+      /**
+       * When set, this package re-shapes the wallet's token outputs instead of
+       * sending a payment. Publishing it returns `SwapCompleted`: rebuild the
+       * original send from the same prepare response and submit again.
+       */ isSwap: boolean;
+    }) {
+      super('UnsignedTransferPackage', 'TokenBatch');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+      tokenContext: ArrayBuffer;
+      /**
+       * What the batch debits, per token. A batch spanning tokens has no
+       * single amount to report.
+       */ totals: Array<BatchTotal>;
+      /**
+       * When set, this package re-shapes the wallet's token outputs instead of
+       * sending a payment. Publishing it returns `SwapCompleted`: rebuild the
+       * original send from the same prepare response and submit again.
+       */ isSwap: boolean;
+    }): TokenBatch_ {
+      return new TokenBatch_(inner);
+    }
+
+    static instanceOf(obj: any): obj is TokenBatch_ {
+      return obj.tag === UnsignedTransferPackage_Tags.TokenBatch;
+    }
+  }
+
   function instanceOf(obj: any): obj is UnsignedTransferPackage {
     return obj[uniffiTypeNameSymbol] === 'UnsignedTransferPackage';
   }
@@ -31020,6 +33876,7 @@ export const UnsignedTransferPackage = (() => {
     Swap: Swap_,
     Transfer: Transfer_,
     Token: Token_,
+    TokenBatch: TokenBatch_,
   });
 })();
 
@@ -31063,6 +33920,14 @@ const FfiConverterTypeUnsignedTransferPackage = (() => {
             fee: FfiConverterTypeu128.read(from),
             isSwap: FfiConverterBool.read(from),
           });
+        case 4:
+          return new UnsignedTransferPackage.TokenBatch({
+            prepareTokenTransaction:
+              FfiConverterTypeExternalPrepareTokenTransactionRequest.read(from),
+            tokenContext: FfiConverterArrayBuffer.read(from),
+            totals: FfiConverterArrayTypeBatchTotal.read(from),
+            isSwap: FfiConverterBool.read(from),
+          });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
@@ -31107,6 +33972,18 @@ const FfiConverterTypeUnsignedTransferPackage = (() => {
           FfiConverterBool.write(inner.isSwap, into);
           return;
         }
+        case UnsignedTransferPackage_Tags.TokenBatch: {
+          ordinalConverter.write(4, into);
+          const inner = value.inner;
+          FfiConverterTypeExternalPrepareTokenTransactionRequest.write(
+            inner.prepareTokenTransaction,
+            into
+          );
+          FfiConverterArrayBuffer.write(inner.tokenContext, into);
+          FfiConverterArrayTypeBatchTotal.write(inner.totals, into);
+          FfiConverterBool.write(inner.isSwap, into);
+          return;
+        }
         default:
           // Throwing from here means that UnsignedTransferPackage_Tags hasn't matched an ordinal.
           throw new UniffiInternalError.UnexpectedEnumCase();
@@ -31150,6 +34027,18 @@ const FfiConverterTypeUnsignedTransferPackage = (() => {
           size += FfiConverterBool.allocationSize(inner.isSwap);
           return size;
         }
+        case UnsignedTransferPackage_Tags.TokenBatch: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(4);
+          size +=
+            FfiConverterTypeExternalPrepareTokenTransactionRequest.allocationSize(
+              inner.prepareTokenTransaction
+            );
+          size += FfiConverterArrayBuffer.allocationSize(inner.tokenContext);
+          size += FfiConverterArrayTypeBatchTotal.allocationSize(inner.totals);
+          size += FfiConverterBool.allocationSize(inner.isSwap);
+          return size;
+        }
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
@@ -31578,6 +34467,16 @@ export interface BitcoinChainService {
     address: string,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<Array<Utxo>>;
+  /**
+   * Every output ever paid to `address`, spent or not, unlike
+   * [`get_address_utxos`](Self::get_address_utxos) which omits spent ones.
+   * Recovers an output's outpoint and value after it has been spent, so a
+   * swept refund can still be distinguished from one never broadcast.
+   */
+  getAddressTxos(
+    address: string,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<Array<Utxo>>;
   getTransactionStatus(
     txid: string,
     asyncOpts_?: { signal: AbortSignal }
@@ -31586,6 +34485,11 @@ export interface BitcoinChainService {
     txid: string,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<string>;
+  getOutspend(
+    txid: string,
+    vout: /*u32*/ number,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<Outspend>;
   broadcastTransaction(
     tx: string,
     asyncOpts_?: { signal: AbortSignal }
@@ -31649,6 +34553,51 @@ export class BitcoinChainServiceImpl
     }
   }
 
+  /**
+   * Every output ever paid to `address`, spent or not, unlike
+   * [`get_address_utxos`](Self::get_address_utxos) which omits spent ones.
+   * Recovers an output's outpoint and value after it has been spent, so a
+   * swept refund can still be distinguished from one never broadcast.
+   */
+  public async getAddressTxos(
+    address: string,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<Array<Utxo>> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_bitcoinchainservice_get_address_txos(
+            uniffiTypeBitcoinChainServiceImplObjectFactory.clonePointer(this),
+            FfiConverterString.lower(address)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterArrayTypeUtxo.lift.bind(
+          FfiConverterArrayTypeUtxo
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeChainServiceError.lift.bind(
+          FfiConverterTypeChainServiceError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   public async getTransactionStatus(
     txid: string,
     asyncOpts_?: { signal: AbortSignal }
@@ -31725,6 +34674,47 @@ export class BitcoinChainServiceImpl
     }
   }
 
+  public async getOutspend(
+    txid: string,
+    vout: /*u32*/ number,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<Outspend> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_bitcoinchainservice_get_outspend(
+            uniffiTypeBitcoinChainServiceImplObjectFactory.clonePointer(this),
+            FfiConverterString.lower(txid),
+            FfiConverterUInt32.lower(vout)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypeOutspend.lift.bind(
+          FfiConverterTypeOutspend
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeChainServiceError.lift.bind(
+          FfiConverterTypeChainServiceError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   public async broadcastTransaction(
     tx: string,
     asyncOpts_?: { signal: AbortSignal }
@@ -31946,6 +34936,55 @@ const uniffiCallbackInterfaceBitcoinChainService: {
       );
       return uniffiForeignFuture;
     },
+    getAddressTxos: (
+      uniffiHandle: bigint,
+      address: Uint8Array,
+      uniffiFutureCallback: UniffiForeignFutureCompleteRustBuffer,
+      uniffiCallbackData: bigint
+    ) => {
+      const uniffiMakeCall = async (
+        signal: AbortSignal
+      ): Promise<Array<Utxo>> => {
+        const jsCallback =
+          FfiConverterTypeBitcoinChainService.lift(uniffiHandle);
+        return await jsCallback.getAddressTxos(
+          FfiConverterString.lift(address),
+          { signal }
+        );
+      };
+      const uniffiHandleSuccess = (returnValue: Array<Utxo>) => {
+        uniffiFutureCallback.call(
+          uniffiFutureCallback,
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: FfiConverterArrayTypeUtxo.lower(returnValue),
+            callStatus: uniffiCaller.createCallStatus(),
+          }
+        );
+      };
+      const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+        uniffiFutureCallback.call(
+          uniffiFutureCallback,
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: /*empty*/ new Uint8Array(0),
+            // TODO create callstatus with error.
+            callStatus: uniffiCaller.createErrorStatus(code, errorBuf),
+          }
+        );
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*isErrorType:*/ ChainServiceError.instanceOf,
+        /*lowerError:*/ FfiConverterTypeChainServiceError.lower.bind(
+          FfiConverterTypeChainServiceError
+        ),
+        /*lowerString:*/ FfiConverterString.lower
+      );
+      return uniffiForeignFuture;
+    },
     getTransactionStatus: (
       uniffiHandle: bigint,
       txid: Uint8Array,
@@ -32040,6 +35079,55 @@ const uniffiCallbackInterfaceBitcoinChainService: {
       );
       return uniffiForeignFuture;
     },
+    getOutspend: (
+      uniffiHandle: bigint,
+      txid: Uint8Array,
+      vout: number,
+      uniffiFutureCallback: UniffiForeignFutureCompleteRustBuffer,
+      uniffiCallbackData: bigint
+    ) => {
+      const uniffiMakeCall = async (signal: AbortSignal): Promise<Outspend> => {
+        const jsCallback =
+          FfiConverterTypeBitcoinChainService.lift(uniffiHandle);
+        return await jsCallback.getOutspend(
+          FfiConverterString.lift(txid),
+          FfiConverterUInt32.lift(vout),
+          { signal }
+        );
+      };
+      const uniffiHandleSuccess = (returnValue: Outspend) => {
+        uniffiFutureCallback.call(
+          uniffiFutureCallback,
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: FfiConverterTypeOutspend.lower(returnValue),
+            callStatus: uniffiCaller.createCallStatus(),
+          }
+        );
+      };
+      const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+        uniffiFutureCallback.call(
+          uniffiFutureCallback,
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: /*empty*/ new Uint8Array(0),
+            // TODO create callstatus with error.
+            callStatus: uniffiCaller.createErrorStatus(code, errorBuf),
+          }
+        );
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*isErrorType:*/ ChainServiceError.instanceOf,
+        /*lowerError:*/ FfiConverterTypeChainServiceError.lower.bind(
+          FfiConverterTypeChainServiceError
+        ),
+        /*lowerString:*/ FfiConverterString.lower
+      );
+      return uniffiForeignFuture;
+    },
     broadcastTransaction: (
       uniffiHandle: bigint,
       tx: Uint8Array,
@@ -32193,6 +35281,17 @@ export interface BreezSdkInterface {
     request: AuthorizeTransferRequest,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<TransferAuthorization>;
+  /**
+   * Builds the unsigned package for the batch prepared by
+   * [`BreezSdk::prepare_send_batch`], for signing outside the SDK.
+   *
+   * Publish the signed package with
+   * [`BreezSdk::publish_signed_transfer_package`], which returns every payment.
+   */
+  buildUnsignedBatchPackage(
+    request: BuildUnsignedBatchPackageRequest,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<UnsignedTransferPackage>;
   buildUnsignedLnurlPayPackage(
     request: BuildUnsignedLnurlPayPackageRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -32469,10 +35568,37 @@ export interface BreezSdkInterface {
     request: PrepareLnurlPayRequest,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<PrepareLnurlPayResponse>;
+  /**
+   * Prepares a send to several payees, all paid by one transaction.
+   *
+   * Each recipient is a Spark address or a Spark invoice, and one batch may
+   * span several tokens. The response resolves every invoice into the asset
+   * and amount it requests, and reports what the batch debits per asset.
+   *
+   * A batch pays tokens: sending sats to several payees at once is not
+   * supported yet, so a recipient that resolves to sats is rejected.
+   *
+   * A batch that pays a Spark invoice is limited to a single token: the
+   * operators reject a transaction that carries an invoice and pays more
+   * than one. Send those as one batch per token.
+   */
+  prepareSendBatch(
+    request: PrepareSendBatchRequest,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<PrepareSendBatchResponse>;
   prepareSendPayment(
     request: PrepareSendPaymentRequest,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<PrepareSendPaymentResponse>;
+  /**
+   * Quotes a unilateral exit without any funding UTXOs: selects which leaves
+   * would exit, computes the exact fee for the given funding kind, and reports
+   * how much to fund.
+   */
+  prepareUnilateralExit(
+    request: PrepareUnilateralExitRequest,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<PrepareUnilateralExitResponse>;
   publishSignedLnurlPayPackage(
     request: PublishSignedLnurlPayPackageRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -32496,19 +35622,20 @@ export interface BreezSdkInterface {
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<RefundDepositResponse>;
   /**
-   * Runs one pass of the pending-conversion refunder.
+   * Runs one full pass of the pending-conversion refunder and returns how
+   * many conversions were refunded, skipped (held back by a safety window),
+   * or failed.
    *
-   * Iterates over payments whose conversions failed and have a refund
-   * pending, then attempts to refund each one. This is the same logic the
-   * SDK runs internally on a periodic schedule when
-   * `background_tasks_enabled` is `true`. When background tasks are
-   * disabled the periodic refunder does not run, and this method is the
-   * explicit entry point for driving the pass; when background tasks are
-   * enabled, it can be called to force an immediate refund pass.
+   * The pass has two parts: refunding locally-marked failed conversions, and
+   * reconciling against Flashnet's clawback-eligible listing to catch
+   * conversions with no local marker (e.g. a storage write that never
+   * landed). The SDK's periodic background schedule runs only the local
+   * part; the reconcile runs at SDK init and on each call to this method, so
+   * this is the explicit entry point for driving a full pass on demand.
    */
   refundPendingConversions(asyncOpts_?: {
     signal: AbortSignal;
-  }): /*throws*/ Promise<void>;
+  }): /*throws*/ Promise<RefundPendingConversionsResponse>;
   registerLightningAddress(
     request: RegisterLightningAddressRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -32547,6 +35674,20 @@ export interface BreezSdkInterface {
     id: string,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<boolean>;
+  /**
+   * Sends the batch prepared by [`BreezSdk::prepare_send_batch`], returning
+   * one payment per recipient in recipient order.
+   *
+   * Retrying after a failure that leaves the outcome unknown may pay twice:
+   * a token transfer has no idempotency key, since the operator can only be
+   * asked about a transaction by a hash that is computed while broadcasting.
+   * Look for the batch with a `Token` payment details filter on the
+   * transaction hash before sending it again.
+   */
+  sendBatch(
+    request: SendBatchRequest,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<SendBatchResponse>;
   sendPayment(
     request: SendPaymentRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -32567,6 +35708,23 @@ export interface BreezSdkInterface {
     request: SyncWalletRequest,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<SyncWalletResponse>;
+  /**
+   * Builds and signs a complete unilateral exit from a `prepare_unilateral_exit`
+   * quote and the actual funding UTXOs, returning the full transaction set in
+   * 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.
+   */
+  unilateralExit(
+    request: UnilateralExitRequest,
+    signer: CpfpSigner,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<UnilateralExitResponse>;
   /**
    * Unregisters a previously registered webhook.
    *
@@ -32772,6 +35930,52 @@ export class BreezSdk
     }
   }
 
+  /**
+   * Builds the unsigned package for the batch prepared by
+   * [`BreezSdk::prepare_send_batch`], for signing outside the SDK.
+   *
+   * Publish the signed package with
+   * [`BreezSdk::publish_signed_transfer_package`], which returns every payment.
+   */
+  public async buildUnsignedBatchPackage(
+    request: BuildUnsignedBatchPackageRequest,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<UnsignedTransferPackage> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_breezsdk_build_unsigned_batch_package(
+            uniffiTypeBreezSdkObjectFactory.clonePointer(this),
+            FfiConverterTypeBuildUnsignedBatchPackageRequest.lower(request)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypeUnsignedTransferPackage.lift.bind(
+          FfiConverterTypeUnsignedTransferPackage
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSdkError.lift.bind(
+          FfiConverterTypeSdkError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   public async buildUnsignedLnurlPayPackage(
     request: BuildUnsignedLnurlPayPackageRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -34098,6 +37302,59 @@ export class BreezSdk
     }
   }
 
+  /**
+   * Prepares a send to several payees, all paid by one transaction.
+   *
+   * Each recipient is a Spark address or a Spark invoice, and one batch may
+   * span several tokens. The response resolves every invoice into the asset
+   * and amount it requests, and reports what the batch debits per asset.
+   *
+   * A batch pays tokens: sending sats to several payees at once is not
+   * supported yet, so a recipient that resolves to sats is rejected.
+   *
+   * A batch that pays a Spark invoice is limited to a single token: the
+   * operators reject a transaction that carries an invoice and pays more
+   * than one. Send those as one batch per token.
+   */
+  public async prepareSendBatch(
+    request: PrepareSendBatchRequest,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<PrepareSendBatchResponse> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_breezsdk_prepare_send_batch(
+            uniffiTypeBreezSdkObjectFactory.clonePointer(this),
+            FfiConverterTypePrepareSendBatchRequest.lower(request)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypePrepareSendBatchResponse.lift.bind(
+          FfiConverterTypePrepareSendBatchResponse
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSdkError.lift.bind(
+          FfiConverterTypeSdkError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   public async prepareSendPayment(
     request: PrepareSendPaymentRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -34137,6 +37394,50 @@ export class BreezSdk
     }
   }
 
+  /**
+   * Quotes a unilateral exit without any funding UTXOs: selects which leaves
+   * would exit, computes the exact fee for the given funding kind, and reports
+   * how much to fund.
+   */
+  public async prepareUnilateralExit(
+    request: PrepareUnilateralExitRequest,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<PrepareUnilateralExitResponse> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_breezsdk_prepare_unilateral_exit(
+            uniffiTypeBreezSdkObjectFactory.clonePointer(this),
+            FfiConverterTypePrepareUnilateralExitRequest.lower(request)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypePrepareUnilateralExitResponse.lift.bind(
+          FfiConverterTypePrepareUnilateralExitResponse
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSdkError.lift.bind(
+          FfiConverterTypeSdkError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   public async publishSignedLnurlPayPackage(
     request: PublishSignedLnurlPayPackageRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -34334,19 +37635,20 @@ export class BreezSdk
   }
 
   /**
-   * Runs one pass of the pending-conversion refunder.
+   * Runs one full pass of the pending-conversion refunder and returns how
+   * many conversions were refunded, skipped (held back by a safety window),
+   * or failed.
    *
-   * Iterates over payments whose conversions failed and have a refund
-   * pending, then attempts to refund each one. This is the same logic the
-   * SDK runs internally on a periodic schedule when
-   * `background_tasks_enabled` is `true`. When background tasks are
-   * disabled the periodic refunder does not run, and this method is the
-   * explicit entry point for driving the pass; when background tasks are
-   * enabled, it can be called to force an immediate refund pass.
+   * The pass has two parts: refunding locally-marked failed conversions, and
+   * reconciling against Flashnet's clawback-eligible listing to catch
+   * conversions with no local marker (e.g. a storage write that never
+   * landed). The SDK's periodic background schedule runs only the local
+   * part; the reconcile runs at SDK init and on each call to this method, so
+   * this is the explicit entry point for driving a full pass on demand.
    */
   public async refundPendingConversions(asyncOpts_?: {
     signal: AbortSignal;
-  }): Promise<void> /*throws*/ {
+  }): Promise<RefundPendingConversionsResponse> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(
@@ -34357,14 +37659,16 @@ export class BreezSdk
           );
         },
         /*pollFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_poll_void,
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
         /*cancelFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_void,
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
         /*completeFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_complete_void,
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
         /*freeFunc:*/ nativeModule()
-          .ubrn_ffi_breez_sdk_spark_rust_future_free_void,
-        /*liftFunc:*/ (_v) => {},
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypeRefundPendingConversionsResponse.lift.bind(
+          FfiConverterTypeRefundPendingConversionsResponse
+        ),
         /*liftString:*/ FfiConverterString.lift,
         /*asyncOpts:*/ asyncOpts_,
         /*errorHandler:*/ FfiConverterTypeSdkError.lift.bind(
@@ -34517,6 +37821,55 @@ export class BreezSdk
     }
   }
 
+  /**
+   * Sends the batch prepared by [`BreezSdk::prepare_send_batch`], returning
+   * one payment per recipient in recipient order.
+   *
+   * Retrying after a failure that leaves the outcome unknown may pay twice:
+   * a token transfer has no idempotency key, since the operator can only be
+   * asked about a transaction by a hash that is computed while broadcasting.
+   * Look for the batch with a `Token` payment details filter on the
+   * transaction hash before sending it again.
+   */
+  public async sendBatch(
+    request: SendBatchRequest,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<SendBatchResponse> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_breezsdk_send_batch(
+            uniffiTypeBreezSdkObjectFactory.clonePointer(this),
+            FfiConverterTypeSendBatchRequest.lower(request)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypeSendBatchResponse.lift.bind(
+          FfiConverterTypeSendBatchResponse
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSdkError.lift.bind(
+          FfiConverterTypeSdkError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   public async sendPayment(
     request: SendPaymentRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -34642,6 +37995,59 @@ export class BreezSdk
     }
   }
 
+  /**
+   * Builds and signs a complete unilateral exit from a `prepare_unilateral_exit`
+   * quote and the actual funding UTXOs, returning the full transaction set in
+   * 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.
+   */
+  public async unilateralExit(
+    request: UnilateralExitRequest,
+    signer: CpfpSigner,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<UnilateralExitResponse> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_breezsdk_unilateral_exit(
+            uniffiTypeBreezSdkObjectFactory.clonePointer(this),
+            FfiConverterTypeUnilateralExitRequest.lower(request),
+            FfiConverterTypeCpfpSigner.lower(signer)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypeUnilateralExitResponse.lift.bind(
+          FfiConverterTypeUnilateralExitResponse
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSdkError.lift.bind(
+          FfiConverterTypeSdkError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   /**
    * Unregisters a previously registered webhook.
    *
@@ -34867,6 +38273,233 @@ const FfiConverterTypeBreezSdk = new FfiConverterObject(
   uniffiTypeBreezSdkObjectFactory
 );
 
+/**
+ * Signer for external UTXO inputs in CPFP fee-bumping transactions.
+ *
+ * Signs the non-finalized inputs of a PSBT (serialized as bytes) and returns the
+ * signed PSBT (also serialized as bytes).
+ */
+export interface CpfpSigner {
+  signPsbt(
+    psbtBytes: ArrayBuffer,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<ArrayBuffer>;
+}
+
+/**
+ * Signer for external UTXO inputs in CPFP fee-bumping transactions.
+ *
+ * Signs the non-finalized inputs of a PSBT (serialized as bytes) and returns the
+ * signed PSBT (also serialized as bytes).
+ */
+export class CpfpSignerImpl extends UniffiAbstractObject implements CpfpSigner {
+  readonly [uniffiTypeNameSymbol] = 'CpfpSignerImpl';
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+  // No primary constructor declared for this class.
+  private constructor(pointer: UnsafeMutableRawPointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] =
+      uniffiTypeCpfpSignerImplObjectFactory.bless(pointer);
+  }
+
+  public async signPsbt(
+    psbtBytes: ArrayBuffer,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<ArrayBuffer> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_cpfpsigner_sign_psbt(
+            uniffiTypeCpfpSignerImplObjectFactory.clonePointer(this),
+            FfiConverterArrayBuffer.lower(psbtBytes)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterArrayBuffer.lift.bind(
+          FfiConverterArrayBuffer
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSignerError.lift.bind(
+          FfiConverterTypeSignerError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeCpfpSignerImplObjectFactory.pointer(this);
+      uniffiTypeCpfpSignerImplObjectFactory.freePointer(pointer);
+      uniffiTypeCpfpSignerImplObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is CpfpSignerImpl {
+    return uniffiTypeCpfpSignerImplObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeCpfpSignerImplObjectFactory: UniffiObjectFactory<CpfpSigner> =
+  (() => {
+    return {
+      create(pointer: UnsafeMutableRawPointer): CpfpSigner {
+        const instance = Object.create(CpfpSignerImpl.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = 'CpfpSignerImpl';
+        return instance;
+      },
+
+      bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+        return uniffiCaller.rustCall(
+          /*caller:*/ (status) =>
+            nativeModule().ubrn_uniffi_internal_fn_method_cpfpsigner_ffi__bless_pointer(
+              p,
+              status
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      unbless(ptr: UniffiRustArcPtr) {
+        ptr.markDestroyed();
+      },
+
+      pointer(obj: CpfpSigner): UnsafeMutableRawPointer {
+        if ((obj as any)[destructorGuardSymbol] === undefined) {
+          throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj as any)[pointerLiteralSymbol];
+      },
+
+      clonePointer(obj: CpfpSigner): UnsafeMutableRawPointer {
+        const pointer = this.pointer(obj);
+        return uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_breez_sdk_spark_fn_clone_cpfpsigner(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      freePointer(pointer: UnsafeMutableRawPointer): void {
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_breez_sdk_spark_fn_free_cpfpsigner(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      isConcreteType(obj: any): obj is CpfpSigner {
+        return (
+          obj[destructorGuardSymbol] &&
+          obj[uniffiTypeNameSymbol] === 'CpfpSignerImpl'
+        );
+      },
+    };
+  })();
+// FfiConverter for CpfpSigner
+const FfiConverterTypeCpfpSigner = new FfiConverterObjectWithCallbacks(
+  uniffiTypeCpfpSignerImplObjectFactory
+);
+
+// Add a vtavble for the callbacks that go in CpfpSigner.
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceCpfpSigner: {
+  vtable: UniffiVTableCallbackInterfaceCpfpSigner;
+  register: () => void;
+} = {
+  // Create the VTable using a series of closures.
+  // ts automatically converts these into C callback functions.
+  vtable: {
+    signPsbt: (
+      uniffiHandle: bigint,
+      psbtBytes: Uint8Array,
+      uniffiFutureCallback: UniffiForeignFutureCompleteRustBuffer,
+      uniffiCallbackData: bigint
+    ) => {
+      const uniffiMakeCall = async (
+        signal: AbortSignal
+      ): Promise<ArrayBuffer> => {
+        const jsCallback = FfiConverterTypeCpfpSigner.lift(uniffiHandle);
+        return await jsCallback.signPsbt(
+          FfiConverterArrayBuffer.lift(psbtBytes),
+          { signal }
+        );
+      };
+      const uniffiHandleSuccess = (returnValue: ArrayBuffer) => {
+        uniffiFutureCallback.call(
+          uniffiFutureCallback,
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: FfiConverterArrayBuffer.lower(returnValue),
+            callStatus: uniffiCaller.createCallStatus(),
+          }
+        );
+      };
+      const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+        uniffiFutureCallback.call(
+          uniffiFutureCallback,
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: /*empty*/ new Uint8Array(0),
+            // TODO create callstatus with error.
+            callStatus: uniffiCaller.createErrorStatus(code, errorBuf),
+          }
+        );
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*isErrorType:*/ SignerError.instanceOf,
+        /*lowerError:*/ FfiConverterTypeSignerError.lower.bind(
+          FfiConverterTypeSignerError
+        ),
+        /*lowerString:*/ FfiConverterString.lower
+      );
+      return uniffiForeignFuture;
+    },
+    uniffiFree: (uniffiHandle: UniffiHandle): void => {
+      // CpfpSigner: this will throw a stale handle error if the handle isn't found.
+      FfiConverterTypeCpfpSigner.drop(uniffiHandle);
+    },
+  },
+  register: () => {
+    nativeModule().ubrn_uniffi_breez_sdk_spark_fn_init_callback_vtable_cpfpsigner(
+      uniffiCallbackInterfaceCpfpSigner.vtable
+    );
+  },
+};
+
 /**
  * External signer trait that can be implemented by users and passed to the SDK.
  *
@@ -36524,6 +40157,15 @@ export interface ExternalSparkSigner {
     message: ArrayBuffer,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<EcdsaSignatureBytes>;
+  /**
+   * Schnorr-sign `sighash` to spend a tree leaf's P2TR refund output as a
+   * BIP341 key-path spend (empty script tree).
+   */
+  signLeafRefundSpend(
+    leafId: ExternalTreeNodeId,
+    sighash: ArrayBuffer,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<SchnorrSignatureBytes>;
   /**
    * Produce FROST shares for a batch of jobs.
    */
@@ -36842,6 +40484,51 @@ export class ExternalSparkSignerImpl
     }
   }
 
+  /**
+   * Schnorr-sign `sighash` to spend a tree leaf's P2TR refund output as a
+   * BIP341 key-path spend (empty script tree).
+   */
+  public async signLeafRefundSpend(
+    leafId: ExternalTreeNodeId,
+    sighash: ArrayBuffer,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<SchnorrSignatureBytes> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_externalsparksigner_sign_leaf_refund_spend(
+            uniffiTypeExternalSparkSignerImplObjectFactory.clonePointer(this),
+            FfiConverterTypeExternalTreeNodeId.lower(leafId),
+            FfiConverterArrayBuffer.lower(sighash)
+          );
+        },
+        /*pollFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_cancel_rust_buffer,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+        /*freeFunc:*/ nativeModule()
+          .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+        /*liftFunc:*/ FfiConverterTypeSchnorrSignatureBytes.lift.bind(
+          FfiConverterTypeSchnorrSignatureBytes
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSignerError.lift.bind(
+          FfiConverterTypeSignerError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   /**
    * Produce FROST shares for a batch of jobs.
    */
@@ -37632,6 +41319,58 @@ const uniffiCallbackInterfaceExternalSparkSigner: {
       );
       return uniffiForeignFuture;
     },
+    signLeafRefundSpend: (
+      uniffiHandle: bigint,
+      leafId: Uint8Array,
+      sighash: Uint8Array,
+      uniffiFutureCallback: UniffiForeignFutureCompleteRustBuffer,
+      uniffiCallbackData: bigint
+    ) => {
+      const uniffiMakeCall = async (
+        signal: AbortSignal
+      ): Promise<SchnorrSignatureBytes> => {
+        const jsCallback =
+          FfiConverterTypeExternalSparkSigner.lift(uniffiHandle);
+        return await jsCallback.signLeafRefundSpend(
+          FfiConverterTypeExternalTreeNodeId.lift(leafId),
+          FfiConverterArrayBuffer.lift(sighash),
+          { signal }
+        );
+      };
+      const uniffiHandleSuccess = (returnValue: SchnorrSignatureBytes) => {
+        uniffiFutureCallback.call(
+          uniffiFutureCallback,
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue:
+              FfiConverterTypeSchnorrSignatureBytes.lower(returnValue),
+            callStatus: uniffiCaller.createCallStatus(),
+          }
+        );
+      };
+      const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+        uniffiFutureCallback.call(
+          uniffiFutureCallback,
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: /*empty*/ new Uint8Array(0),
+            // TODO create callstatus with error.
+            callStatus: uniffiCaller.createErrorStatus(code, errorBuf),
+          }
+        );
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*isErrorType:*/ SignerError.instanceOf,
+        /*lowerError:*/ FfiConverterTypeSignerError.lower.bind(
+          FfiConverterTypeSignerError
+        ),
+        /*lowerString:*/ FfiConverterString.lower
+      );
+      return uniffiForeignFuture;
+    },
     signFrost: (
       uniffiHandle: bigint,
       jobs: Uint8Array,
@@ -38534,10 +42273,12 @@ export interface PasskeyClientInterface {
    */
   labels(): PasskeyLabelsInterface;
   /**
-   * First-time setup. Drives [`PrfProvider::create_passkey`] (one
-   * ceremony) followed by the wallet-derivation flow that backs
-   * [`Passkey::setup_wallet`] (one ceremony, dual-salt where
-   * supported). The label is always published on success.
+   * First-time setup. Drives [`PrfProvider::create_passkey`], which
+   * returns the seeds inline where the platform evaluates PRF during
+   * the create ceremony; otherwise the wallet-derivation flow behind
+   * [`Passkey::setup_wallet`] runs as a second ceremony. The label is
+   * validated before anything is created, and published in the
+   * background: it may still be in flight when this returns `Ok`.
    */
   register(
     request: RegisterRequest,
@@ -38723,10 +42464,12 @@ export class PasskeyClient
   }
 
   /**
-   * First-time setup. Drives [`PrfProvider::create_passkey`] (one
-   * ceremony) followed by the wallet-derivation flow that backs
-   * [`Passkey::setup_wallet`] (one ceremony, dual-salt where
-   * supported). The label is always published on success.
+   * First-time setup. Drives [`PrfProvider::create_passkey`], which
+   * returns the seeds inline where the platform evaluates PRF during
+   * the create ceremony; otherwise the wallet-derivation flow behind
+   * [`Passkey::setup_wallet`] runs as a second ceremony. The label is
+   * validated before anything is created, and published in the
+   * background: it may still be in flight when this returns `Ok`.
    */
   public async register(
     request: RegisterRequest,
@@ -39464,20 +43207,35 @@ export interface PrfProvider {
     signal: AbortSignal;
   }): /*throws*/ Promise<boolean>;
   /**
-   * Explicit registration. Platform passkey providers override this to
-   * drive the OS create ceremony and surface the credential metadata
-   * hosts need for `exclude_credentials` bookkeeping. CLI / hardware
-   * providers register lazily in [`Self::derive_seeds`] and inherit the
-   * default `PrfNotSupported`.
+   * Explicit registration: drive the OS create ceremony, and where the
+   * platform supports it, evaluate PRF for `salts` in the same
+   * ceremony. Platform passkey providers override this to surface the
+   * credential metadata hosts need for `exclude_credentials`
+   * bookkeeping. CLI / hardware providers register lazily in
+   * [`Self::derive_seeds`] and inherit the default `PrfNotSupported`.
    *
    * `exclude_credentials` lists already-registered IDs and surfaces
    * duplicates as `CredentialAlreadyExists`. The `user.id` is always
    * provider-minted and returned on `PasskeyCredential.user_id`.
+   *
+   * Returning seeds removes the assertion that would otherwise follow
+   * a create, and with it the window where the new credential exists
+   * but the platform cannot yet resolve it. Return `seeds: None` for
+   * anything short of one output per salt (some authenticators drop
+   * `prf.eval.second`): a partial result is not usable, and the caller
+   * falls back to [`Self::derive_seeds`]. Empty `salts` means the
+   * caller wants the credential only.
+   *
+   * Seeds returned here must equal what [`Self::derive_seeds`] would
+   * return for the same salts. The wallet is derived from them either
+   * way, so a mismatch means register and sign-in land on different
+   * wallets, and the one register created is unreachable.
    */
   createPasskey(
     excludeCredentials: Array<ArrayBuffer>,
+    salts: Array<string>,
     asyncOpts_?: { signal: AbortSignal }
-  ): /*throws*/ Promise<PasskeyCredential>;
+  ): /*throws*/ Promise<CreatePasskeyOutput>;
   /**
    * Advisory check against the platform's out-of-band verification
    * source (iOS AASA / Android assetlinks / browser rpId scope).
@@ -39614,20 +43372,35 @@ export class PrfProviderImpl
   }
 
   /**
-   * Explicit registration. Platform passkey providers override this to
-   * drive the OS create ceremony and surface the credential metadata
-   * hosts need for `exclude_credentials` bookkeeping. CLI / hardware
-   * providers register lazily in [`Self::derive_seeds`] and inherit the
-   * default `PrfNotSupported`.
+   * Explicit registration: drive the OS create ceremony, and where the
+   * platform supports it, evaluate PRF for `salts` in the same
+   * ceremony. Platform passkey providers override this to surface the
+   * credential metadata hosts need for `exclude_credentials`
+   * bookkeeping. CLI / hardware providers register lazily in
+   * [`Self::derive_seeds`] and inherit the default `PrfNotSupported`.
    *
    * `exclude_credentials` lists already-registered IDs and surfaces
    * duplicates as `CredentialAlreadyExists`. The `user.id` is always
    * provider-minted and returned on `PasskeyCredential.user_id`.
+   *
+   * Returning seeds removes the assertion that would otherwise follow
+   * a create, and with it the window where the new credential exists
+   * but the platform cannot yet resolve it. Return `seeds: None` for
+   * anything short of one output per salt (some authenticators drop
+   * `prf.eval.second`): a partial result is not usable, and the caller
+   * falls back to [`Self::derive_seeds`]. Empty `salts` means the
+   * caller wants the credential only.
+   *
+   * Seeds returned here must equal what [`Self::derive_seeds`] would
+   * return for the same salts. The wallet is derived from them either
+   * way, so a mismatch means register and sign-in land on different
+   * wallets, and the one register created is unreachable.
    */
   public async createPasskey(
     excludeCredentials: Array<ArrayBuffer>,
+    salts: Array<string>,
     asyncOpts_?: { signal: AbortSignal }
-  ): Promise<PasskeyCredential> /*throws*/ {
+  ): Promise<CreatePasskeyOutput> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(
@@ -39635,7 +43408,8 @@ export class PrfProviderImpl
         /*rustFutureFunc:*/ () => {
           return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_prfprovider_create_passkey(
             uniffiTypePrfProviderImplObjectFactory.clonePointer(this),
-            FfiConverterArrayArrayBuffer.lower(excludeCredentials)
+            FfiConverterArrayArrayBuffer.lower(excludeCredentials),
+            FfiConverterArrayString.lower(salts)
           );
         },
         /*pollFunc:*/ nativeModule()
@@ -39646,8 +43420,8 @@ export class PrfProviderImpl
           .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
         /*freeFunc:*/ nativeModule()
           .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
-        /*liftFunc:*/ FfiConverterTypePasskeyCredential.lift.bind(
-          FfiConverterTypePasskeyCredential
+        /*liftFunc:*/ FfiConverterTypeCreatePasskeyOutput.lift.bind(
+          FfiConverterTypeCreatePasskeyOutput
         ),
         /*liftString:*/ FfiConverterString.lift,
         /*asyncOpts:*/ asyncOpts_,
@@ -39904,24 +43678,26 @@ const uniffiCallbackInterfacePrfProvider: {
     createPasskey: (
       uniffiHandle: bigint,
       excludeCredentials: Uint8Array,
+      salts: Uint8Array,
       uniffiFutureCallback: UniffiForeignFutureCompleteRustBuffer,
       uniffiCallbackData: bigint
     ) => {
       const uniffiMakeCall = async (
         signal: AbortSignal
-      ): Promise<PasskeyCredential> => {
+      ): Promise<CreatePasskeyOutput> => {
         const jsCallback = FfiConverterTypePrfProvider.lift(uniffiHandle);
         return await jsCallback.createPasskey(
           FfiConverterArrayArrayBuffer.lift(excludeCredentials),
+          FfiConverterArrayString.lift(salts),
           { signal }
         );
       };
-      const uniffiHandleSuccess = (returnValue: PasskeyCredential) => {
+      const uniffiHandleSuccess = (returnValue: CreatePasskeyOutput) => {
         uniffiFutureCallback.call(
           uniffiFutureCallback,
           uniffiCallbackData,
           /* UniffiForeignFutureStructRustBuffer */ {
-            returnValue: FfiConverterTypePasskeyCredential.lower(returnValue),
+            returnValue: FfiConverterTypeCreatePasskeyOutput.lower(returnValue),
             callStatus: uniffiCaller.createCallStatus(),
           }
         );
@@ -45839,6 +49615,16 @@ const FfiConverterArrayArrayBuffer = new FfiConverterArray(
   FfiConverterArrayBuffer
 );
 
+// FfiConverter for Array<BatchRecipient>
+const FfiConverterArrayTypeBatchRecipient = new FfiConverterArray(
+  FfiConverterTypeBatchRecipient
+);
+
+// FfiConverter for Array<BatchTotal>
+const FfiConverterArrayTypeBatchTotal = new FfiConverterArray(
+  FfiConverterTypeBatchTotal
+);
+
 // FfiConverter for Array<Bip21Extra>
 const FfiConverterArrayTypeBip21Extra = new FfiConverterArray(
   FfiConverterTypeBip21Extra
@@ -45969,6 +49755,11 @@ const FfiConverterArrayTypePaymentIdUpdate = new FfiConverterArray(
   FfiConverterTypePaymentIdUpdate
 );
 
+// FfiConverter for Array<PerBranchFunding>
+const FfiConverterArrayTypePerBranchFunding = new FfiConverterArray(
+  FfiConverterTypePerBranchFunding
+);
+
 // FfiConverter for Array<ProvisionalPayment>
 const FfiConverterArrayTypeProvisionalPayment = new FfiConverterArray(
   FfiConverterTypeProvisionalPayment
@@ -45982,6 +49773,11 @@ const FfiConverterArrayTypeRecord = new FfiConverterArray(
   FfiConverterTypeRecord
 );
 
+// FfiConverter for Array<ResolvedBatchRecipient>
+const FfiConverterArrayTypeResolvedBatchRecipient = new FfiConverterArray(
+  FfiConverterTypeResolvedBatchRecipient
+);
+
 // FfiConverter for Array<SetLnurlMetadataItem>
 const FfiConverterArrayTypeSetLnurlMetadataItem = new FfiConverterArray(
   FfiConverterTypeSetLnurlMetadataItem
@@ -46007,6 +49803,16 @@ const FfiConverterArrayTypeTokenMetadata = new FfiConverterArray(
   FfiConverterTypeTokenMetadata
 );
 
+// FfiConverter for Array<UnilateralExitLeaf>
+const FfiConverterArrayTypeUnilateralExitLeaf = new FfiConverterArray(
+  FfiConverterTypeUnilateralExitLeaf
+);
+
+// FfiConverter for Array<UnilateralExitTransaction>
+const FfiConverterArrayTypeUnilateralExitTransaction = new FfiConverterArray(
+  FfiConverterTypeUnilateralExitTransaction
+);
+
 // FfiConverter for Array<Utxo>
 const FfiConverterArrayTypeUtxo = new FfiConverterArray(FfiConverterTypeUtxo);
 
@@ -46101,6 +49907,10 @@ const FfiConverterOptionalTypeSendPaymentOptions = new FfiConverterOptional(
   FfiConverterTypeSendPaymentOptions
 );
 
+// FfiConverter for SparkMasterIdentityPublicKey | undefined
+const FfiConverterOptionalTypeSparkMasterIdentityPublicKey =
+  new FfiConverterOptional(FfiConverterTypeSparkMasterIdentityPublicKey);
+
 // FfiConverter for StableBalanceActiveLabel | undefined
 const FfiConverterOptionalTypeStableBalanceActiveLabel =
   new FfiConverterOptional(FfiConverterTypeStableBalanceActiveLabel);
@@ -46139,6 +49949,11 @@ const FfiConverterOptionalArrayArrayBuffer = new FfiConverterOptional(
 const FfiConverterOptionalArrayTypeExternalInputParser =
   new FfiConverterOptional(FfiConverterArrayTypeExternalInputParser);
 
+// FfiConverter for Array<CpfpInput>
+const FfiConverterArrayTypeCpfpInput = new FfiConverterArray(
+  FfiConverterTypeCpfpInput
+);
+
 // FfiConverter for Array<InputType>
 const FfiConverterArrayTypeInputType = new FfiConverterArray(
   FfiConverterTypeInputType
@@ -46343,6 +50158,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_func_new_shared_sdk_context'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_func_single_key_cpfp_signer() !==
+    28762
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_func_single_key_cpfp_signer'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_address_utxos() !==
     20959
@@ -46351,9 +50174,17 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_address_utxos'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_address_txos() !==
+    10702
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_address_txos'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_transaction_status() !==
-    23018
+    53546
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_transaction_status'
@@ -46361,15 +50192,23 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_transaction_hex() !==
-    59376
+    16866
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_transaction_hex'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_outspend() !==
+    42521
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_get_outspend'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_broadcast_transaction() !==
-    65179
+    13500
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_broadcast_transaction'
@@ -46377,7 +50216,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_recommended_fees() !==
-    43230
+    50885
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_bitcoinchainservice_recommended_fees'
@@ -46407,6 +50246,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_authorize_lightning_address_transfer'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_build_unsigned_batch_package() !==
+    52999
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_breezsdk_build_unsigned_batch_package'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_build_unsigned_lnurl_pay_package() !==
     23822
@@ -46655,6 +50502,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_prepare_lnurl_pay'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_prepare_send_batch() !==
+    59347
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_breezsdk_prepare_send_batch'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_prepare_send_payment() !==
     34185
@@ -46663,6 +50518,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_prepare_send_payment'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_prepare_unilateral_exit() !==
+    36492
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_breezsdk_prepare_unilateral_exit'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_publish_signed_lnurl_pay_package() !==
     48698
@@ -46705,7 +50568,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_refund_pending_conversions() !==
-    24173
+    11342
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_refund_pending_conversions'
@@ -46735,6 +50598,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_remove_event_listener'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_send_batch() !==
+    34563
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_breezsdk_send_batch'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_send_payment() !==
     54349
@@ -46759,6 +50630,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_sync_wallet'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_unilateral_exit() !==
+    23033
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_breezsdk_unilateral_exit'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_unregister_webhook() !==
     34100
@@ -46783,6 +50662,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_update_user_settings'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_cpfpsigner_sign_psbt() !==
+    20736
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_cpfpsigner_sign_psbt'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalbreezsigner_derive_public_key() !==
     26700
@@ -46919,9 +50806,17 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_message'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_leaf_refund_spend() !==
+    62629
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_leaf_refund_spend'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_frost() !==
-    41995
+    58732
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_frost'
@@ -46929,7 +50824,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_transfer() !==
-    7663
+    29829
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_transfer'
@@ -46937,7 +50832,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_claim() !==
-    40463
+    17684
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_claim'
@@ -46945,7 +50840,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_lightning_receive() !==
-    22362
+    25306
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_lightning_receive'
@@ -46953,7 +50848,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_static_deposit() !==
-    44945
+    3348
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_static_deposit'
@@ -46961,7 +50856,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_start_static_deposit_refund() !==
-    15575
+    22709
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_start_static_deposit_refund'
@@ -46969,7 +50864,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_static_deposit_refund() !==
-    3082
+    52719
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_static_deposit_refund'
@@ -46977,7 +50872,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_spark_invoice() !==
-    33
+    39737
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_sign_spark_invoice'
@@ -46985,7 +50880,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_token_transaction() !==
-    33122
+    12801
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_token_transaction'
@@ -46993,7 +50888,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_static_deposit_claim() !==
-    14601
+    53174
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsparksigner_prepare_static_deposit_claim'
@@ -47041,7 +50936,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_passkeyclient_register() !==
-    18330
+    27748
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_passkeyclient_register'
@@ -47105,7 +51000,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_prfprovider_create_passkey() !==
-    1967
+    61235
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_prfprovider_create_passkey'
@@ -47611,6 +51506,7 @@ function uniffiEnsureInitialized() {
   uniffiCallbackInterfaceEventListener.register();
   uniffiCallbackInterfaceLogger.register();
   uniffiCallbackInterfaceBitcoinChainService.register();
+  uniffiCallbackInterfaceCpfpSigner.register();
   uniffiCallbackInterfaceExternalBreezSigner.register();
   uniffiCallbackInterfaceExternalSigningSigner.register();
   uniffiCallbackInterfaceExternalSparkSigner.register();
@@ -47634,6 +51530,9 @@ export default Object.freeze({
     FfiConverterTypeAssetFilter,
     FfiConverterTypeAuthorizeTransferRequest,
     FfiConverterTypeAutoOptimizationEvent,
+    FfiConverterTypeBatchDestination,
+    FfiConverterTypeBatchRecipient,
+    FfiConverterTypeBatchTotal,
     FfiConverterTypeBip21Details,
     FfiConverterTypeBip21Extra,
     FfiConverterTypeBitcoinAddressDetails,
@@ -47651,6 +51550,7 @@ export default Object.freeze({
     FfiConverterTypeBolt12OfferDetails,
     FfiConverterTypeBreezSdk,
     FfiConverterTypeBuildTransferPackageOptions,
+    FfiConverterTypeBuildUnsignedBatchPackageRequest,
     FfiConverterTypeBuildUnsignedLnurlPayPackageRequest,
     FfiConverterTypeBuildUnsignedTransferPackageRequest,
     FfiConverterTypeBurnIssuerTokenRequest,
@@ -47667,6 +51567,7 @@ export default Object.freeze({
     FfiConverterTypeClaimHtlcPaymentResponse,
     FfiConverterTypeClaimTransferRequest,
     FfiConverterTypeConfig,
+    FfiConverterTypeConfirmationStatus,
     FfiConverterTypeConnectRequest,
     FfiConverterTypeConnectWithPasskeyRequest,
     FfiConverterTypeConnectWithPasskeyResponse,
@@ -47686,7 +51587,11 @@ export default Object.freeze({
     FfiConverterTypeConversionSide,
     FfiConverterTypeConversionStatus,
     FfiConverterTypeConversionType,
+    FfiConverterTypeCpfpFundingKind,
+    FfiConverterTypeCpfpInput,
+    FfiConverterTypeCpfpSigner,
     FfiConverterTypeCreateIssuerTokenRequest,
+    FfiConverterTypeCreatePasskeyOutput,
     FfiConverterTypeCredentials,
     FfiConverterTypeCrossChainAddressDetails,
     FfiConverterTypeCrossChainAddressFamily,
@@ -47704,6 +51609,7 @@ export default Object.freeze({
     FfiConverterTypeDomainAssociation,
     FfiConverterTypeEcdsaSignatureBytes,
     FfiConverterTypeErrorKind,
+    FfiConverterTypeExitLeafSelection,
     FfiConverterTypeExternalBreezSigner,
     FfiConverterTypeExternalClaimLeafInput,
     FfiConverterTypeExternalFrostCommitments,
@@ -47800,6 +51706,7 @@ export default Object.freeze({
     FfiConverterTypeOptimizeLeavesRequest,
     FfiConverterTypeOptimizeLeavesResponse,
     FfiConverterTypeOutgoingChange,
+    FfiConverterTypeOutspend,
     FfiConverterTypePasskeyAvailability,
     FfiConverterTypePasskeyClient,
     FfiConverterTypePasskeyConfig,
@@ -47819,10 +51726,15 @@ export default Object.freeze({
     FfiConverterTypePaymentRequestSource,
     FfiConverterTypePaymentStatus,
     FfiConverterTypePaymentType,
+    FfiConverterTypePerBranchFunding,
     FfiConverterTypePrepareLnurlPayRequest,
     FfiConverterTypePrepareLnurlPayResponse,
+    FfiConverterTypePrepareSendBatchRequest,
+    FfiConverterTypePrepareSendBatchResponse,
     FfiConverterTypePrepareSendPaymentRequest,
     FfiConverterTypePrepareSendPaymentResponse,
+    FfiConverterTypePrepareUnilateralExitRequest,
+    FfiConverterTypePrepareUnilateralExitResponse,
     FfiConverterTypePrfProvider,
     FfiConverterTypePrfProviderError,
     FfiConverterTypeProvisionalPayment,
@@ -47844,11 +51756,13 @@ export default Object.freeze({
     FfiConverterTypeRecoverableEcdsaSignatureBytes,
     FfiConverterTypeRefundDepositRequest,
     FfiConverterTypeRefundDepositResponse,
+    FfiConverterTypeRefundPendingConversionsResponse,
     FfiConverterTypeRegisterLightningAddressRequest,
     FfiConverterTypeRegisterRequest,
     FfiConverterTypeRegisterResponse,
     FfiConverterTypeRegisterWebhookRequest,
     FfiConverterTypeRegisterWebhookResponse,
+    FfiConverterTypeResolvedBatchRecipient,
     FfiConverterTypeResolvedStores,
     FfiConverterTypeRestClient,
     FfiConverterTypeRestResponse,
@@ -47860,6 +51774,8 @@ export default Object.freeze({
     FfiConverterTypeSdkEvent,
     FfiConverterTypeSecretBytes,
     FfiConverterTypeSeed,
+    FfiConverterTypeSendBatchRequest,
+    FfiConverterTypeSendBatchResponse,
     FfiConverterTypeSendOnchainFeeQuote,
     FfiConverterTypeSendOnchainSpeedFeeQuote,
     FfiConverterTypeSendPaymentMethod,
@@ -47889,6 +51805,7 @@ export default Object.freeze({
     FfiConverterTypeSparkHtlcStatus,
     FfiConverterTypeSparkInvoiceDetails,
     FfiConverterTypeSparkInvoicePaymentDetails,
+    FfiConverterTypeSparkMasterIdentityPublicKey,
     FfiConverterTypeSparkSigningOperator,
     FfiConverterTypeSparkSspConfig,
     FfiConverterTypeSparkStatus,
@@ -47919,6 +51836,11 @@ export default Object.freeze({
     FfiConverterTypeTxStatus,
     FfiConverterTypeUnfreezeIssuerTokenRequest,
     FfiConverterTypeUnfreezeIssuerTokenResponse,
+    FfiConverterTypeUnilateralExitLeaf,
+    FfiConverterTypeUnilateralExitRequest,
+    FfiConverterTypeUnilateralExitResponse,
+    FfiConverterTypeUnilateralExitTransaction,
+    FfiConverterTypeUnilateralExitTxKind,
     FfiConverterTypeUnregisterWebhookRequest,
     FfiConverterTypeUnsignedTransferPackage,
     FfiConverterTypeUnversionedRecordChange,