@breeztech/breez-sdk-spark-react-native 0.7.2 → 0.7.4

package/src/generated/breez_sdk_spark.ts

@@ -2116,6 +2116,253 @@ const FfiConverterTypeConnectWithSignerRequest = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Response from estimating a conversion, used when preparing a payment that requires conversion
+ */
+export type ConversionEstimate = {
+  /**
+   * The conversion options used for the estimate
+   */
+  options: ConversionOptions;
+  /**
+   * The estimated amount to be received from the conversion
+   * Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
+   */
+  amount: U128;
+  /**
+   * The fee estimated for the conversion
+   * Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
+   */
+  fee: U128;
+};
+
+/**
+ * Generated factory for {@link ConversionEstimate} record objects.
+ */
+export const ConversionEstimate = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ConversionEstimate, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ConversionEstimate}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ConversionEstimate}, 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<ConversionEstimate>,
+  });
+})();
+
+const FfiConverterTypeConversionEstimate = (() => {
+  type TypeName = ConversionEstimate;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        options: FfiConverterTypeConversionOptions.read(from),
+        amount: FfiConverterTypeu128.read(from),
+        fee: FfiConverterTypeu128.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeConversionOptions.write(value.options, into);
+      FfiConverterTypeu128.write(value.amount, into);
+      FfiConverterTypeu128.write(value.fee, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeConversionOptions.allocationSize(value.options) +
+        FfiConverterTypeu128.allocationSize(value.amount) +
+        FfiConverterTypeu128.allocationSize(value.fee)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type ConversionInfo = {
+  /**
+   * The pool id associated with the conversion
+   */
+  poolId: string;
+  /**
+   * The conversion id shared by both sides of the conversion
+   */
+  conversionId: string;
+  /**
+   * The status of the conversion
+   */
+  status: ConversionStatus;
+  /**
+   * The fee paid for the conversion
+   * Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
+   */
+  fee: U128 | undefined;
+  /**
+   * The purpose of the conversion
+   */
+  purpose: ConversionPurpose | undefined;
+};
+
+/**
+ * Generated factory for {@link ConversionInfo} record objects.
+ */
+export const ConversionInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ConversionInfo, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ConversionInfo}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ConversionInfo}, 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<ConversionInfo>,
+  });
+})();
+
+const FfiConverterTypeConversionInfo = (() => {
+  type TypeName = ConversionInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        poolId: FfiConverterString.read(from),
+        conversionId: FfiConverterString.read(from),
+        status: FfiConverterTypeConversionStatus.read(from),
+        fee: FfiConverterOptionalTypeu128.read(from),
+        purpose: FfiConverterOptionalTypeConversionPurpose.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.poolId, into);
+      FfiConverterString.write(value.conversionId, into);
+      FfiConverterTypeConversionStatus.write(value.status, into);
+      FfiConverterOptionalTypeu128.write(value.fee, into);
+      FfiConverterOptionalTypeConversionPurpose.write(value.purpose, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.poolId) +
+        FfiConverterString.allocationSize(value.conversionId) +
+        FfiConverterTypeConversionStatus.allocationSize(value.status) +
+        FfiConverterOptionalTypeu128.allocationSize(value.fee) +
+        FfiConverterOptionalTypeConversionPurpose.allocationSize(value.purpose)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Options for conversion when fulfilling a payment. When set, the SDK will
+ * perform a conversion before fulfilling the payment. If not set, the payment
+ * will only be fulfilled if the wallet has sufficient balance of the required asset.
+ */
+export type ConversionOptions = {
+  /**
+   * The type of conversion to perform when fulfilling the payment
+   */
+  conversionType: ConversionType;
+  /**
+   * The optional maximum slippage in basis points (1/100 of a percent) allowed when
+   * a conversion is needed to fulfill the payment. Defaults to 50 bps (0.5%) if not set.
+   * The conversion will fail if the actual amount received is less than
+   * `estimated_amount * (1 - max_slippage_bps / 10_000)`.
+   */
+  maxSlippageBps: /*u32*/ number | undefined;
+  /**
+   * The optional timeout in seconds to wait for the conversion to complete
+   * when fulfilling the payment. This timeout only concerns waiting for the received
+   * payment of the conversion. If the timeout is reached before the conversion
+   * is complete, the payment will fail. Defaults to 30 seconds if not set.
+   */
+  completionTimeoutSecs: /*u32*/ number | undefined;
+};
+
+/**
+ * Generated factory for {@link ConversionOptions} record objects.
+ */
+export const ConversionOptions = (() => {
+  const defaults = () => ({
+    maxSlippageBps: undefined,
+    completionTimeoutSecs: undefined,
+  });
+  const create = (() => {
+    return uniffiCreateRecord<ConversionOptions, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ConversionOptions}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link ConversionOptions}, 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<ConversionOptions>,
+  });
+})();
+
+const FfiConverterTypeConversionOptions = (() => {
+  type TypeName = ConversionOptions;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        conversionType: FfiConverterTypeConversionType.read(from),
+        maxSlippageBps: FfiConverterOptionalUInt32.read(from),
+        completionTimeoutSecs: FfiConverterOptionalUInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeConversionType.write(value.conversionType, into);
+      FfiConverterOptionalUInt32.write(value.maxSlippageBps, into);
+      FfiConverterOptionalUInt32.write(value.completionTimeoutSecs, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeConversionType.allocationSize(value.conversionType) +
+        FfiConverterOptionalUInt32.allocationSize(value.maxSlippageBps) +
+        FfiConverterOptionalUInt32.allocationSize(value.completionTimeoutSecs)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type CreateIssuerTokenRequest = {
   name: string;
   ticker: string;
@@ -3441,11 +3688,11 @@ const FfiConverterTypeExternalVerifiableSecretShare = (() => {
   return new FFIConverter();
 })();
 
-export type FetchTokenConversionLimitsRequest = {
+export type FetchConversionLimitsRequest = {
   /**
    * The type of conversion, either from or to Bitcoin.
    */
-  conversionType: TokenConversionType;
+  conversionType: ConversionType;
   /**
    * The token identifier when converting to a token.
    */
@@ -3453,25 +3700,25 @@ export type FetchTokenConversionLimitsRequest = {
 };
 
 /**
- * Generated factory for {@link FetchTokenConversionLimitsRequest} record objects.
+ * Generated factory for {@link FetchConversionLimitsRequest} record objects.
  */
-export const FetchTokenConversionLimitsRequest = (() => {
+export const FetchConversionLimitsRequest = (() => {
   const defaults = () => ({ tokenIdentifier: undefined });
   const create = (() => {
     return uniffiCreateRecord<
-      FetchTokenConversionLimitsRequest,
+      FetchConversionLimitsRequest,
       ReturnType<typeof defaults>
     >(defaults);
   })();
   return Object.freeze({
     /**
-     * Create a frozen instance of {@link FetchTokenConversionLimitsRequest}, with defaults specified
+     * Create a frozen instance of {@link FetchConversionLimitsRequest}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
     create,
 
     /**
-     * Create a frozen instance of {@link FetchTokenConversionLimitsRequest}, with defaults specified
+     * Create a frozen instance of {@link FetchConversionLimitsRequest}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
     new: create,
@@ -3480,35 +3727,34 @@ export const FetchTokenConversionLimitsRequest = (() => {
      * Defaults specified in the {@link breez_sdk_spark} crate.
      */
     defaults: () =>
-      Object.freeze(defaults()) as Partial<FetchTokenConversionLimitsRequest>,
+      Object.freeze(defaults()) as Partial<FetchConversionLimitsRequest>,
   });
 })();
 
-const FfiConverterTypeFetchTokenConversionLimitsRequest = (() => {
-  type TypeName = FetchTokenConversionLimitsRequest;
+const FfiConverterTypeFetchConversionLimitsRequest = (() => {
+  type TypeName = FetchConversionLimitsRequest;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        conversionType: FfiConverterTypeTokenConversionType.read(from),
+        conversionType: FfiConverterTypeConversionType.read(from),
         tokenIdentifier: FfiConverterOptionalString.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterTypeTokenConversionType.write(value.conversionType, into);
+      FfiConverterTypeConversionType.write(value.conversionType, into);
       FfiConverterOptionalString.write(value.tokenIdentifier, into);
     }
     allocationSize(value: TypeName): number {
       return (
-        FfiConverterTypeTokenConversionType.allocationSize(
-          value.conversionType
-        ) + FfiConverterOptionalString.allocationSize(value.tokenIdentifier)
+        FfiConverterTypeConversionType.allocationSize(value.conversionType) +
+        FfiConverterOptionalString.allocationSize(value.tokenIdentifier)
       );
     }
   }
   return new FFIConverter();
 })();
 
-export type FetchTokenConversionLimitsResponse = {
+export type FetchConversionLimitsResponse = {
   /**
    * The minimum amount to be converted.
    * Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
@@ -3522,25 +3768,25 @@ export type FetchTokenConversionLimitsResponse = {
 };
 
 /**
- * Generated factory for {@link FetchTokenConversionLimitsResponse} record objects.
+ * Generated factory for {@link FetchConversionLimitsResponse} record objects.
  */
-export const FetchTokenConversionLimitsResponse = (() => {
+export const FetchConversionLimitsResponse = (() => {
   const defaults = () => ({});
   const create = (() => {
     return uniffiCreateRecord<
-      FetchTokenConversionLimitsResponse,
+      FetchConversionLimitsResponse,
       ReturnType<typeof defaults>
     >(defaults);
   })();
   return Object.freeze({
     /**
-     * Create a frozen instance of {@link FetchTokenConversionLimitsResponse}, with defaults specified
+     * Create a frozen instance of {@link FetchConversionLimitsResponse}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
     create,
 
     /**
-     * Create a frozen instance of {@link FetchTokenConversionLimitsResponse}, with defaults specified
+     * Create a frozen instance of {@link FetchConversionLimitsResponse}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
     new: create,
@@ -3549,12 +3795,12 @@ export const FetchTokenConversionLimitsResponse = (() => {
      * Defaults specified in the {@link breez_sdk_spark} crate.
      */
     defaults: () =>
-      Object.freeze(defaults()) as Partial<FetchTokenConversionLimitsResponse>,
+      Object.freeze(defaults()) as Partial<FetchConversionLimitsResponse>,
   });
 })();
 
-const FfiConverterTypeFetchTokenConversionLimitsResponse = (() => {
-  type TypeName = FetchTokenConversionLimitsResponse;
+const FfiConverterTypeFetchConversionLimitsResponse = (() => {
+  type TypeName = FetchConversionLimitsResponse;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
@@ -4089,6 +4335,58 @@ const FfiConverterTypeGetTokensMetadataResponse = (() => {
   return new FFIConverter();
 })();
 
+export type HashedMessageBytes = {
+  bytes: ArrayBuffer;
+};
+
+/**
+ * Generated factory for {@link HashedMessageBytes} record objects.
+ */
+export const HashedMessageBytes = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<HashedMessageBytes, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link HashedMessageBytes}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link HashedMessageBytes}, 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<HashedMessageBytes>,
+  });
+})();
+
+const FfiConverterTypeHashedMessageBytes = (() => {
+  type TypeName = HashedMessageBytes;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        bytes: FfiConverterArrayBuffer.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayBuffer.write(value.bytes, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterArrayBuffer.allocationSize(value.bytes);
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * FFI-safe wrapper for (Identifier, `SigningCommitments`) pair
  */
@@ -5040,36 +5338,31 @@ const FfiConverterTypeLnurlAuthRequestDetails = (() => {
 })();
 
 /**
- * Represents the payment LNURL info
+ * LNURL error details
  */
-export type LnurlPayInfo = {
-  lnAddress: string | undefined;
-  comment: string | undefined;
-  domain: string | undefined;
-  metadata: string | undefined;
-  processedSuccessAction: SuccessActionProcessed | undefined;
-  rawSuccessAction: SuccessAction | undefined;
+export type LnurlErrorDetails = {
+  reason: string;
 };
 
 /**
- * Generated factory for {@link LnurlPayInfo} record objects.
+ * Generated factory for {@link LnurlErrorDetails} record objects.
  */
-export const LnurlPayInfo = (() => {
+export const LnurlErrorDetails = (() => {
   const defaults = () => ({});
   const create = (() => {
-    return uniffiCreateRecord<LnurlPayInfo, ReturnType<typeof defaults>>(
+    return uniffiCreateRecord<LnurlErrorDetails, ReturnType<typeof defaults>>(
       defaults
     );
   })();
   return Object.freeze({
     /**
-     * Create a frozen instance of {@link LnurlPayInfo}, with defaults specified
+     * Create a frozen instance of {@link LnurlErrorDetails}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
     create,
 
     /**
-     * Create a frozen instance of {@link LnurlPayInfo}, with defaults specified
+     * Create a frozen instance of {@link LnurlErrorDetails}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
     new: create,
@@ -5077,29 +5370,89 @@ export const LnurlPayInfo = (() => {
     /**
      * Defaults specified in the {@link breez_sdk_spark} crate.
      */
-    defaults: () => Object.freeze(defaults()) as Partial<LnurlPayInfo>,
+    defaults: () => Object.freeze(defaults()) as Partial<LnurlErrorDetails>,
   });
 })();
 
-const FfiConverterTypeLnurlPayInfo = (() => {
-  type TypeName = LnurlPayInfo;
+const FfiConverterTypeLnurlErrorDetails = (() => {
+  type TypeName = LnurlErrorDetails;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       return {
-        lnAddress: FfiConverterOptionalString.read(from),
-        comment: FfiConverterOptionalString.read(from),
-        domain: FfiConverterOptionalString.read(from),
-        metadata: FfiConverterOptionalString.read(from),
-        processedSuccessAction:
-          FfiConverterOptionalTypeSuccessActionProcessed.read(from),
-        rawSuccessAction: FfiConverterOptionalTypeSuccessAction.read(from),
+        reason: FfiConverterString.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
-      FfiConverterOptionalString.write(value.lnAddress, into);
-      FfiConverterOptionalString.write(value.comment, into);
-      FfiConverterOptionalString.write(value.domain, into);
-      FfiConverterOptionalString.write(value.metadata, into);
+      FfiConverterString.write(value.reason, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterString.allocationSize(value.reason);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Represents the payment LNURL info
+ */
+export type LnurlPayInfo = {
+  lnAddress: string | undefined;
+  comment: string | undefined;
+  domain: string | undefined;
+  metadata: string | undefined;
+  processedSuccessAction: SuccessActionProcessed | undefined;
+  rawSuccessAction: SuccessAction | undefined;
+};
+
+/**
+ * Generated factory for {@link LnurlPayInfo} record objects.
+ */
+export const LnurlPayInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<LnurlPayInfo, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LnurlPayInfo}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link LnurlPayInfo}, 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<LnurlPayInfo>,
+  });
+})();
+
+const FfiConverterTypeLnurlPayInfo = (() => {
+  type TypeName = LnurlPayInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        lnAddress: FfiConverterOptionalString.read(from),
+        comment: FfiConverterOptionalString.read(from),
+        domain: FfiConverterOptionalString.read(from),
+        metadata: FfiConverterOptionalString.read(from),
+        processedSuccessAction:
+          FfiConverterOptionalTypeSuccessActionProcessed.read(from),
+        rawSuccessAction: FfiConverterOptionalTypeSuccessAction.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterOptionalString.write(value.lnAddress, into);
+      FfiConverterOptionalString.write(value.comment, into);
+      FfiConverterOptionalString.write(value.domain, into);
+      FfiConverterOptionalString.write(value.metadata, into);
       FfiConverterOptionalTypeSuccessActionProcessed.write(
         value.processedSuccessAction,
         into
@@ -5900,6 +6253,61 @@ const FfiConverterTypeLogEntry = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * FFI-safe representation of a 32-byte message digest for ECDSA signing
+ */
+export type MessageBytes = {
+  bytes: ArrayBuffer;
+};
+
+/**
+ * Generated factory for {@link MessageBytes} record objects.
+ */
+export const MessageBytes = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<MessageBytes, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link MessageBytes}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link MessageBytes}, 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<MessageBytes>,
+  });
+})();
+
+const FfiConverterTypeMessageBytes = (() => {
+  type TypeName = MessageBytes;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        bytes: FfiConverterArrayBuffer.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterArrayBuffer.write(value.bytes, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterArrayBuffer.allocationSize(value.bytes);
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type MessageSuccessActionData = {
   message: string;
 };
@@ -6320,7 +6728,7 @@ export type PaymentMetadata = {
   lnurlPayInfo: LnurlPayInfo | undefined;
   lnurlWithdrawInfo: LnurlWithdrawInfo | undefined;
   lnurlDescription: string | undefined;
-  tokenConversionInfo: TokenConversionInfo | undefined;
+  conversionInfo: ConversionInfo | undefined;
 };
 
 /**
@@ -6362,8 +6770,7 @@ const FfiConverterTypePaymentMetadata = (() => {
         lnurlPayInfo: FfiConverterOptionalTypeLnurlPayInfo.read(from),
         lnurlWithdrawInfo: FfiConverterOptionalTypeLnurlWithdrawInfo.read(from),
         lnurlDescription: FfiConverterOptionalString.read(from),
-        tokenConversionInfo:
-          FfiConverterOptionalTypeTokenConversionInfo.read(from),
+        conversionInfo: FfiConverterOptionalTypeConversionInfo.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
@@ -6374,10 +6781,7 @@ const FfiConverterTypePaymentMetadata = (() => {
         into
       );
       FfiConverterOptionalString.write(value.lnurlDescription, into);
-      FfiConverterOptionalTypeTokenConversionInfo.write(
-        value.tokenConversionInfo,
-        into
-      );
+      FfiConverterOptionalTypeConversionInfo.write(value.conversionInfo, into);
     }
     allocationSize(value: TypeName): number {
       return (
@@ -6389,8 +6793,8 @@ const FfiConverterTypePaymentMetadata = (() => {
           value.lnurlWithdrawInfo
         ) +
         FfiConverterOptionalString.allocationSize(value.lnurlDescription) +
-        FfiConverterOptionalTypeTokenConversionInfo.allocationSize(
-          value.tokenConversionInfo
+        FfiConverterOptionalTypeConversionInfo.allocationSize(
+          value.conversionInfo
         )
       );
     }
@@ -6625,9 +7029,9 @@ export type PrepareSendPaymentRequest = {
    */
   tokenIdentifier: string | undefined;
   /**
-   * If provided, the payment will include a token conversion step before sending the payment
+   * If provided, the payment will include a conversion step before sending the payment
    */
-  tokenConversionOptions: TokenConversionOptions | undefined;
+  conversionOptions: ConversionOptions | undefined;
 };
 
 /**
@@ -6637,7 +7041,7 @@ export const PrepareSendPaymentRequest = (() => {
   const defaults = () => ({
     amount: undefined,
     tokenIdentifier: undefined,
-    tokenConversionOptions: undefined,
+    conversionOptions: undefined,
   });
   const create = (() => {
     return uniffiCreateRecord<
@@ -6674,16 +7078,15 @@ const FfiConverterTypePrepareSendPaymentRequest = (() => {
         paymentRequest: FfiConverterString.read(from),
         amount: FfiConverterOptionalTypeu128.read(from),
         tokenIdentifier: FfiConverterOptionalString.read(from),
-        tokenConversionOptions:
-          FfiConverterOptionalTypeTokenConversionOptions.read(from),
+        conversionOptions: FfiConverterOptionalTypeConversionOptions.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
       FfiConverterString.write(value.paymentRequest, into);
       FfiConverterOptionalTypeu128.write(value.amount, into);
       FfiConverterOptionalString.write(value.tokenIdentifier, into);
-      FfiConverterOptionalTypeTokenConversionOptions.write(
-        value.tokenConversionOptions,
+      FfiConverterOptionalTypeConversionOptions.write(
+        value.conversionOptions,
         into
       );
     }
@@ -6692,8 +7095,8 @@ const FfiConverterTypePrepareSendPaymentRequest = (() => {
         FfiConverterString.allocationSize(value.paymentRequest) +
         FfiConverterOptionalTypeu128.allocationSize(value.amount) +
         FfiConverterOptionalString.allocationSize(value.tokenIdentifier) +
-        FfiConverterOptionalTypeTokenConversionOptions.allocationSize(
-          value.tokenConversionOptions
+        FfiConverterOptionalTypeConversionOptions.allocationSize(
+          value.conversionOptions
         )
       );
     }
@@ -6714,13 +7117,9 @@ export type PrepareSendPaymentResponse = {
    */
   tokenIdentifier: string | undefined;
   /**
-   * When set, the payment will include a token conversion step before sending the payment
+   * When set, the payment will include a conversion step before sending the payment
    */
-  tokenConversionOptions: TokenConversionOptions | undefined;
-  /**
-   * The estimated token conversion fee if the payment involves a token conversion
-   */
-  tokenConversionFee: U128 | undefined;
+  conversionEstimate: ConversionEstimate | undefined;
 };
 
 /**
@@ -6763,30 +7162,27 @@ const FfiConverterTypePrepareSendPaymentResponse = (() => {
         paymentMethod: FfiConverterTypeSendPaymentMethod.read(from),
         amount: FfiConverterTypeu128.read(from),
         tokenIdentifier: FfiConverterOptionalString.read(from),
-        tokenConversionOptions:
-          FfiConverterOptionalTypeTokenConversionOptions.read(from),
-        tokenConversionFee: FfiConverterOptionalTypeu128.read(from),
+        conversionEstimate:
+          FfiConverterOptionalTypeConversionEstimate.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
       FfiConverterTypeSendPaymentMethod.write(value.paymentMethod, into);
       FfiConverterTypeu128.write(value.amount, into);
       FfiConverterOptionalString.write(value.tokenIdentifier, into);
-      FfiConverterOptionalTypeTokenConversionOptions.write(
-        value.tokenConversionOptions,
+      FfiConverterOptionalTypeConversionEstimate.write(
+        value.conversionEstimate,
         into
       );
-      FfiConverterOptionalTypeu128.write(value.tokenConversionFee, into);
     }
     allocationSize(value: TypeName): number {
       return (
         FfiConverterTypeSendPaymentMethod.allocationSize(value.paymentMethod) +
         FfiConverterTypeu128.allocationSize(value.amount) +
         FfiConverterOptionalString.allocationSize(value.tokenIdentifier) +
-        FfiConverterOptionalTypeTokenConversionOptions.allocationSize(
-          value.tokenConversionOptions
-        ) +
-        FfiConverterOptionalTypeu128.allocationSize(value.tokenConversionFee)
+        FfiConverterOptionalTypeConversionEstimate.allocationSize(
+          value.conversionEstimate
+        )
       );
     }
   }
@@ -8361,7 +8757,7 @@ export type SparkHtlcDetails = {
    */
   preimage: string | undefined;
   /**
-   * The expiry time of the HTLC in seconds since the Unix epoch
+   * The expiry time of the HTLC as a unix timestamp in seconds
    */
   expiryTime: /*u64*/ bigint;
   /**
@@ -8513,7 +8909,7 @@ export type SparkInvoiceDetails = {
    */
   tokenIdentifier: string | undefined;
   /**
-   * Optional expiry time. If not provided, the invoice will never expire.
+   * Optional expiry time as a unix timestamp in seconds. If not provided, the invoice will never expire.
    */
   expiryTime: /*u64*/ bigint | undefined;
   /**
@@ -8886,174 +9282,6 @@ const FfiConverterTypeTokenBalance = (() => {
   return new FFIConverter();
 })();
 
-export type TokenConversionInfo = {
-  /**
-   * The pool id associated with the conversion
-   */
-  poolId: string;
-  /**
-   * The receiving payment id associated with the conversion
-   */
-  paymentId: string | undefined;
-  /**
-   * The fee paid for the conversion
-   * Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
-   */
-  fee: U128 | undefined;
-  /**
-   * The refund payment id if a refund payment was made
-   */
-  refundIdentifier: string | undefined;
-};
-
-/**
- * Generated factory for {@link TokenConversionInfo} record objects.
- */
-export const TokenConversionInfo = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord<TokenConversionInfo, ReturnType<typeof defaults>>(
-      defaults
-    );
-  })();
-  return Object.freeze({
-    /**
-     * Create a frozen instance of {@link TokenConversionInfo}, with defaults specified
-     * in Rust, in the {@link breez_sdk_spark} crate.
-     */
-    create,
-
-    /**
-     * Create a frozen instance of {@link TokenConversionInfo}, 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<TokenConversionInfo>,
-  });
-})();
-
-const FfiConverterTypeTokenConversionInfo = (() => {
-  type TypeName = TokenConversionInfo;
-  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-    read(from: RustBuffer): TypeName {
-      return {
-        poolId: FfiConverterString.read(from),
-        paymentId: FfiConverterOptionalString.read(from),
-        fee: FfiConverterOptionalTypeu128.read(from),
-        refundIdentifier: FfiConverterOptionalString.read(from),
-      };
-    }
-    write(value: TypeName, into: RustBuffer): void {
-      FfiConverterString.write(value.poolId, into);
-      FfiConverterOptionalString.write(value.paymentId, into);
-      FfiConverterOptionalTypeu128.write(value.fee, into);
-      FfiConverterOptionalString.write(value.refundIdentifier, into);
-    }
-    allocationSize(value: TypeName): number {
-      return (
-        FfiConverterString.allocationSize(value.poolId) +
-        FfiConverterOptionalString.allocationSize(value.paymentId) +
-        FfiConverterOptionalTypeu128.allocationSize(value.fee) +
-        FfiConverterOptionalString.allocationSize(value.refundIdentifier)
-      );
-    }
-  }
-  return new FFIConverter();
-})();
-
-/**
- * Options for token conversion when fulfilling a payment. When set, the SDK will
- * perform a token conversion before fulfilling the payment. If not set, the payment
- * will only be fulfilled if the wallet has sufficient balance of the required asset.
- */
-export type TokenConversionOptions = {
-  /**
-   * The type of token conversion to perform when fulfilling the payment
-   */
-  conversionType: TokenConversionType;
-  /**
-   * The optional maximum slippage in basis points (1/100 of a percent) allowed when
-   * a token conversion is needed to fulfill the payment. Defaults to 50 bps (0.5%) if not set.
-   * The token conversion will fail if the actual amount received is less than
-   * `estimated_amount * (1 - max_slippage_bps / 10_000)`.
-   */
-  maxSlippageBps: /*u32*/ number | undefined;
-  /**
-   * The optional timeout in seconds to wait for the token conversion to complete
-   * when fulfilling the payment. This timeout only concerns waiting for the received
-   * payment of the token conversion. If the timeout is reached before the conversion
-   * is complete, the payment will fail. Defaults to 30 seconds if not set.
-   */
-  completionTimeoutSecs: /*u32*/ number | undefined;
-};
-
-/**
- * Generated factory for {@link TokenConversionOptions} record objects.
- */
-export const TokenConversionOptions = (() => {
-  const defaults = () => ({
-    maxSlippageBps: undefined,
-    completionTimeoutSecs: undefined,
-  });
-  const create = (() => {
-    return uniffiCreateRecord<
-      TokenConversionOptions,
-      ReturnType<typeof defaults>
-    >(defaults);
-  })();
-  return Object.freeze({
-    /**
-     * Create a frozen instance of {@link TokenConversionOptions}, with defaults specified
-     * in Rust, in the {@link breez_sdk_spark} crate.
-     */
-    create,
-
-    /**
-     * Create a frozen instance of {@link TokenConversionOptions}, 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<TokenConversionOptions>,
-  });
-})();
-
-const FfiConverterTypeTokenConversionOptions = (() => {
-  type TypeName = TokenConversionOptions;
-  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-    read(from: RustBuffer): TypeName {
-      return {
-        conversionType: FfiConverterTypeTokenConversionType.read(from),
-        maxSlippageBps: FfiConverterOptionalUInt32.read(from),
-        completionTimeoutSecs: FfiConverterOptionalUInt32.read(from),
-      };
-    }
-    write(value: TypeName, into: RustBuffer): void {
-      FfiConverterTypeTokenConversionType.write(value.conversionType, into);
-      FfiConverterOptionalUInt32.write(value.maxSlippageBps, into);
-      FfiConverterOptionalUInt32.write(value.completionTimeoutSecs, into);
-    }
-    allocationSize(value: TypeName): number {
-      return (
-        FfiConverterTypeTokenConversionType.allocationSize(
-          value.conversionType
-        ) +
-        FfiConverterOptionalUInt32.allocationSize(value.maxSlippageBps) +
-        FfiConverterOptionalUInt32.allocationSize(value.completionTimeoutSecs)
-      );
-    }
-  }
-  return new FFIConverter();
-})();
-
 export type TokenMetadata = {
   identifier: string;
   /**
@@ -10407,16 +10635,350 @@ const FfiConverterTypeChainServiceError = (() => {
           size += FfiConverterString.allocationSize(inner[0]);
           return size;
         }
-        case ChainServiceError_Tags.ServiceConnectivity: {
+        case ChainServiceError_Tags.ServiceConnectivity: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterString.allocationSize(inner[0]);
+          return size;
+        }
+        case ChainServiceError_Tags.Generic: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner[0]);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Enum: ConversionPurpose
+export enum ConversionPurpose_Tags {
+  OngoingPayment = 'OngoingPayment',
+  SelfTransfer = 'SelfTransfer',
+}
+/**
+ * The purpose of the conversion, which is used to provide context for the conversion
+ * if its related to an ongoing payment or a self-transfer.
+ */
+export const ConversionPurpose = (() => {
+  type OngoingPayment__interface = {
+    tag: ConversionPurpose_Tags.OngoingPayment;
+    inner: Readonly<{ paymentRequest: string }>;
+  };
+
+  /**
+   * Conversion is associated with an ongoing payment
+   */
+  class OngoingPayment_
+    extends UniffiEnum
+    implements OngoingPayment__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ConversionPurpose';
+    readonly tag = ConversionPurpose_Tags.OngoingPayment;
+    readonly inner: Readonly<{ paymentRequest: string }>;
+    constructor(inner: {
+      /**
+       * The payment request of the ongoing payment
+       */ paymentRequest: string;
+    }) {
+      super('ConversionPurpose', 'OngoingPayment');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: {
+      /**
+       * The payment request of the ongoing payment
+       */ paymentRequest: string;
+    }): OngoingPayment_ {
+      return new OngoingPayment_(inner);
+    }
+
+    static instanceOf(obj: any): obj is OngoingPayment_ {
+      return obj.tag === ConversionPurpose_Tags.OngoingPayment;
+    }
+  }
+
+  type SelfTransfer__interface = {
+    tag: ConversionPurpose_Tags.SelfTransfer;
+  };
+
+  /**
+   * Conversion is for self-transfer
+   */
+  class SelfTransfer_ extends UniffiEnum implements SelfTransfer__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ConversionPurpose';
+    readonly tag = ConversionPurpose_Tags.SelfTransfer;
+    constructor() {
+      super('ConversionPurpose', 'SelfTransfer');
+    }
+
+    static new(): SelfTransfer_ {
+      return new SelfTransfer_();
+    }
+
+    static instanceOf(obj: any): obj is SelfTransfer_ {
+      return obj.tag === ConversionPurpose_Tags.SelfTransfer;
+    }
+  }
+
+  function instanceOf(obj: any): obj is ConversionPurpose {
+    return obj[uniffiTypeNameSymbol] === 'ConversionPurpose';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    OngoingPayment: OngoingPayment_,
+    SelfTransfer: SelfTransfer_,
+  });
+})();
+
+/**
+ * The purpose of the conversion, which is used to provide context for the conversion
+ * if its related to an ongoing payment or a self-transfer.
+ */
+
+export type ConversionPurpose = InstanceType<
+  (typeof ConversionPurpose)[keyof Omit<typeof ConversionPurpose, 'instanceOf'>]
+>;
+
+// FfiConverter for enum ConversionPurpose
+const FfiConverterTypeConversionPurpose = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = ConversionPurpose;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new ConversionPurpose.OngoingPayment({
+            paymentRequest: FfiConverterString.read(from),
+          });
+        case 2:
+          return new ConversionPurpose.SelfTransfer();
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case ConversionPurpose_Tags.OngoingPayment: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.paymentRequest, into);
+          return;
+        }
+        case ConversionPurpose_Tags.SelfTransfer: {
+          ordinalConverter.write(2, into);
+          return;
+        }
+        default:
+          // Throwing from here means that ConversionPurpose_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case ConversionPurpose_Tags.OngoingPayment: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.paymentRequest);
+          return size;
+        }
+        case ConversionPurpose_Tags.SelfTransfer: {
+          return ordinalConverter.allocationSize(2);
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * The status of the conversion
+ */
+export enum ConversionStatus {
+  /**
+   * The conversion was successful
+   */
+  Completed,
+  /**
+   * The conversion failed and no refund was made yet, which requires action by the SDK to
+   * perform the refund. This can happen if there was a failure during the conversion process.
+   */
+  RefundNeeded,
+  /**
+   * The conversion failed and a refund was made
+   */
+  Refunded,
+}
+
+const FfiConverterTypeConversionStatus = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = ConversionStatus;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return ConversionStatus.Completed;
+        case 2:
+          return ConversionStatus.RefundNeeded;
+        case 3:
+          return ConversionStatus.Refunded;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case ConversionStatus.Completed:
+          return ordinalConverter.write(1, into);
+        case ConversionStatus.RefundNeeded:
+          return ordinalConverter.write(2, into);
+        case ConversionStatus.Refunded:
+          return ordinalConverter.write(3, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Enum: ConversionType
+export enum ConversionType_Tags {
+  FromBitcoin = 'FromBitcoin',
+  ToBitcoin = 'ToBitcoin',
+}
+export const ConversionType = (() => {
+  type FromBitcoin__interface = {
+    tag: ConversionType_Tags.FromBitcoin;
+  };
+
+  /**
+   * Converting from Bitcoin to a token
+   */
+  class FromBitcoin_ extends UniffiEnum implements FromBitcoin__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ConversionType';
+    readonly tag = ConversionType_Tags.FromBitcoin;
+    constructor() {
+      super('ConversionType', 'FromBitcoin');
+    }
+
+    static new(): FromBitcoin_ {
+      return new FromBitcoin_();
+    }
+
+    static instanceOf(obj: any): obj is FromBitcoin_ {
+      return obj.tag === ConversionType_Tags.FromBitcoin;
+    }
+  }
+
+  type ToBitcoin__interface = {
+    tag: ConversionType_Tags.ToBitcoin;
+    inner: Readonly<{ fromTokenIdentifier: string }>;
+  };
+
+  /**
+   * Converting from a token to Bitcoin
+   */
+  class ToBitcoin_ extends UniffiEnum implements ToBitcoin__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'ConversionType';
+    readonly tag = ConversionType_Tags.ToBitcoin;
+    readonly inner: Readonly<{ fromTokenIdentifier: string }>;
+    constructor(inner: { fromTokenIdentifier: string }) {
+      super('ConversionType', 'ToBitcoin');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { fromTokenIdentifier: string }): ToBitcoin_ {
+      return new ToBitcoin_(inner);
+    }
+
+    static instanceOf(obj: any): obj is ToBitcoin_ {
+      return obj.tag === ConversionType_Tags.ToBitcoin;
+    }
+  }
+
+  function instanceOf(obj: any): obj is ConversionType {
+    return obj[uniffiTypeNameSymbol] === 'ConversionType';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    FromBitcoin: FromBitcoin_,
+    ToBitcoin: ToBitcoin_,
+  });
+})();
+
+export type ConversionType = InstanceType<
+  (typeof ConversionType)[keyof Omit<typeof ConversionType, 'instanceOf'>]
+>;
+
+// FfiConverter for enum ConversionType
+const FfiConverterTypeConversionType = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = ConversionType;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new ConversionType.FromBitcoin();
+        case 2:
+          return new ConversionType.ToBitcoin({
+            fromTokenIdentifier: FfiConverterString.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case ConversionType_Tags.FromBitcoin: {
+          ordinalConverter.write(1, into);
+          return;
+        }
+        case ConversionType_Tags.ToBitcoin: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.fromTokenIdentifier, into);
+          return;
+        }
+        default:
+          // Throwing from here means that ConversionType_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case ConversionType_Tags.FromBitcoin: {
+          return ordinalConverter.allocationSize(1);
+        }
+        case ConversionType_Tags.ToBitcoin: {
           const inner = value.inner;
           let size = ordinalConverter.allocationSize(2);
-          size += FfiConverterString.allocationSize(inner[0]);
-          return size;
-        }
-        case ChainServiceError_Tags.Generic: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(3);
-          size += FfiConverterString.allocationSize(inner[0]);
+          size += FfiConverterString.allocationSize(inner.fromTokenIdentifier);
           return size;
         }
         default:
@@ -11836,6 +12398,149 @@ const FfiConverterTypeKeySetType = (() => {
   return new FFIConverter();
 })();
 
+// Enum: LnurlCallbackStatus
+export enum LnurlCallbackStatus_Tags {
+  Ok = 'Ok',
+  ErrorStatus = 'ErrorStatus',
+}
+/**
+ * The response from a LNURL-auth callback, indicating success or failure.
+ */
+export const LnurlCallbackStatus = (() => {
+  type Ok__interface = {
+    tag: LnurlCallbackStatus_Tags.Ok;
+  };
+
+  /**
+   * On-wire format is: `{"status": "OK"}`
+   */
+  class Ok_ extends UniffiEnum implements Ok__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LnurlCallbackStatus';
+    readonly tag = LnurlCallbackStatus_Tags.Ok;
+    constructor() {
+      super('LnurlCallbackStatus', 'Ok');
+    }
+
+    static new(): Ok_ {
+      return new Ok_();
+    }
+
+    static instanceOf(obj: any): obj is Ok_ {
+      return obj.tag === LnurlCallbackStatus_Tags.Ok;
+    }
+  }
+
+  type ErrorStatus__interface = {
+    tag: LnurlCallbackStatus_Tags.ErrorStatus;
+    inner: Readonly<{ errorDetails: LnurlErrorDetails }>;
+  };
+
+  /**
+   * On-wire format is: `{"status": "ERROR", "reason": "error details..."}`
+   */
+  class ErrorStatus_ extends UniffiEnum implements ErrorStatus__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = 'LnurlCallbackStatus';
+    readonly tag = LnurlCallbackStatus_Tags.ErrorStatus;
+    readonly inner: Readonly<{ errorDetails: LnurlErrorDetails }>;
+    constructor(inner: { errorDetails: LnurlErrorDetails }) {
+      super('LnurlCallbackStatus', 'ErrorStatus');
+      this.inner = Object.freeze(inner);
+    }
+
+    static new(inner: { errorDetails: LnurlErrorDetails }): ErrorStatus_ {
+      return new ErrorStatus_(inner);
+    }
+
+    static instanceOf(obj: any): obj is ErrorStatus_ {
+      return obj.tag === LnurlCallbackStatus_Tags.ErrorStatus;
+    }
+  }
+
+  function instanceOf(obj: any): obj is LnurlCallbackStatus {
+    return obj[uniffiTypeNameSymbol] === 'LnurlCallbackStatus';
+  }
+
+  return Object.freeze({
+    instanceOf,
+    Ok: Ok_,
+    ErrorStatus: ErrorStatus_,
+  });
+})();
+
+/**
+ * The response from a LNURL-auth callback, indicating success or failure.
+ */
+
+export type LnurlCallbackStatus = InstanceType<
+  (typeof LnurlCallbackStatus)[keyof Omit<
+    typeof LnurlCallbackStatus,
+    'instanceOf'
+  >]
+>;
+
+// FfiConverter for enum LnurlCallbackStatus
+const FfiConverterTypeLnurlCallbackStatus = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = LnurlCallbackStatus;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new LnurlCallbackStatus.Ok();
+        case 2:
+          return new LnurlCallbackStatus.ErrorStatus({
+            errorDetails: FfiConverterTypeLnurlErrorDetails.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case LnurlCallbackStatus_Tags.Ok: {
+          ordinalConverter.write(1, into);
+          return;
+        }
+        case LnurlCallbackStatus_Tags.ErrorStatus: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterTypeLnurlErrorDetails.write(inner.errorDetails, into);
+          return;
+        }
+        default:
+          // Throwing from here means that LnurlCallbackStatus_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case LnurlCallbackStatus_Tags.Ok: {
+          return ordinalConverter.allocationSize(1);
+        }
+        case LnurlCallbackStatus_Tags.ErrorStatus: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterTypeLnurlErrorDetails.allocationSize(
+            inner.errorDetails
+          );
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
 // Enum: MaxFee
 export enum MaxFee_Tags {
   Fixed = 'Fixed',
@@ -12427,7 +13132,7 @@ export const PaymentDetails = (() => {
     inner: Readonly<{
       invoiceDetails: SparkInvoicePaymentDetails | undefined;
       htlcDetails: SparkHtlcDetails | undefined;
-      tokenConversionInfo: TokenConversionInfo | undefined;
+      conversionInfo: ConversionInfo | undefined;
     }>;
   };
 
@@ -12441,7 +13146,7 @@ export const PaymentDetails = (() => {
     readonly inner: Readonly<{
       invoiceDetails: SparkInvoicePaymentDetails | undefined;
       htlcDetails: SparkHtlcDetails | undefined;
-      tokenConversionInfo: TokenConversionInfo | undefined;
+      conversionInfo: ConversionInfo | undefined;
     }>;
     constructor(inner: {
       /**
@@ -12451,8 +13156,8 @@ export const PaymentDetails = (() => {
        * The HTLC transfer details if the payment fulfilled an HTLC transfer
        */ htlcDetails: SparkHtlcDetails | undefined;
       /**
-       * The information for a token conversion
-       */ tokenConversionInfo: TokenConversionInfo | undefined;
+       * The information for a conversion
+       */ conversionInfo: ConversionInfo | undefined;
     }) {
       super('PaymentDetails', 'Spark');
       this.inner = Object.freeze(inner);
@@ -12466,8 +13171,8 @@ export const PaymentDetails = (() => {
        * The HTLC transfer details if the payment fulfilled an HTLC transfer
        */ htlcDetails: SparkHtlcDetails | undefined;
       /**
-       * The information for a token conversion
-       */ tokenConversionInfo: TokenConversionInfo | undefined;
+       * The information for a conversion
+       */ conversionInfo: ConversionInfo | undefined;
     }): Spark_ {
       return new Spark_(inner);
     }
@@ -12483,7 +13188,7 @@ export const PaymentDetails = (() => {
       metadata: TokenMetadata;
       txHash: string;
       invoiceDetails: SparkInvoicePaymentDetails | undefined;
-      tokenConversionInfo: TokenConversionInfo | undefined;
+      conversionInfo: ConversionInfo | undefined;
     }>;
   };
 
@@ -12498,7 +13203,7 @@ export const PaymentDetails = (() => {
       metadata: TokenMetadata;
       txHash: string;
       invoiceDetails: SparkInvoicePaymentDetails | undefined;
-      tokenConversionInfo: TokenConversionInfo | undefined;
+      conversionInfo: ConversionInfo | undefined;
     }>;
     constructor(inner: {
       metadata: TokenMetadata;
@@ -12507,8 +13212,8 @@ export const PaymentDetails = (() => {
        * The invoice details if the payment fulfilled a spark invoice
        */ invoiceDetails: SparkInvoicePaymentDetails | undefined;
       /**
-       * The information for a token conversion
-       */ tokenConversionInfo: TokenConversionInfo | undefined;
+       * The information for a conversion
+       */ conversionInfo: ConversionInfo | undefined;
     }) {
       super('PaymentDetails', 'Token');
       this.inner = Object.freeze(inner);
@@ -12521,8 +13226,8 @@ export const PaymentDetails = (() => {
        * The invoice details if the payment fulfilled a spark invoice
        */ invoiceDetails: SparkInvoicePaymentDetails | undefined;
       /**
-       * The information for a token conversion
-       */ tokenConversionInfo: TokenConversionInfo | undefined;
+       * The information for a conversion
+       */ conversionInfo: ConversionInfo | undefined;
     }): Token_ {
       return new Token_(inner);
     }
@@ -12715,8 +13420,7 @@ const FfiConverterTypePaymentDetails = (() => {
             invoiceDetails:
               FfiConverterOptionalTypeSparkInvoicePaymentDetails.read(from),
             htlcDetails: FfiConverterOptionalTypeSparkHtlcDetails.read(from),
-            tokenConversionInfo:
-              FfiConverterOptionalTypeTokenConversionInfo.read(from),
+            conversionInfo: FfiConverterOptionalTypeConversionInfo.read(from),
           });
         case 2:
           return new PaymentDetails.Token({
@@ -12724,8 +13428,7 @@ const FfiConverterTypePaymentDetails = (() => {
             txHash: FfiConverterString.read(from),
             invoiceDetails:
               FfiConverterOptionalTypeSparkInvoicePaymentDetails.read(from),
-            tokenConversionInfo:
-              FfiConverterOptionalTypeTokenConversionInfo.read(from),
+            conversionInfo: FfiConverterOptionalTypeConversionInfo.read(from),
           });
         case 3:
           return new PaymentDetails.Lightning({
@@ -12765,8 +13468,8 @@ const FfiConverterTypePaymentDetails = (() => {
             inner.htlcDetails,
             into
           );
-          FfiConverterOptionalTypeTokenConversionInfo.write(
-            inner.tokenConversionInfo,
+          FfiConverterOptionalTypeConversionInfo.write(
+            inner.conversionInfo,
             into
           );
           return;
@@ -12780,8 +13483,8 @@ const FfiConverterTypePaymentDetails = (() => {
             inner.invoiceDetails,
             into
           );
-          FfiConverterOptionalTypeTokenConversionInfo.write(
-            inner.tokenConversionInfo,
+          FfiConverterOptionalTypeConversionInfo.write(
+            inner.conversionInfo,
             into
           );
           return;
@@ -12834,8 +13537,8 @@ const FfiConverterTypePaymentDetails = (() => {
           size += FfiConverterOptionalTypeSparkHtlcDetails.allocationSize(
             inner.htlcDetails
           );
-          size += FfiConverterOptionalTypeTokenConversionInfo.allocationSize(
-            inner.tokenConversionInfo
+          size += FfiConverterOptionalTypeConversionInfo.allocationSize(
+            inner.conversionInfo
           );
           return size;
         }
@@ -12848,8 +13551,8 @@ const FfiConverterTypePaymentDetails = (() => {
             FfiConverterOptionalTypeSparkInvoicePaymentDetails.allocationSize(
               inner.invoiceDetails
             );
-          size += FfiConverterOptionalTypeTokenConversionInfo.allocationSize(
-            inner.tokenConversionInfo
+          size += FfiConverterOptionalTypeConversionInfo.allocationSize(
+            inner.conversionInfo
           );
           return size;
         }
@@ -13727,7 +14430,7 @@ export const ReceivePaymentMethod = (() => {
        * If empty, it is a Bitcoin payment
        */ tokenIdentifier: string | undefined;
       /**
-       * The expiry time of the invoice in seconds since the Unix epoch
+       * The expiry time of the invoice as a unix timestamp in seconds
        */ expiryTime: /*u64*/ bigint | undefined;
       /**
        * A description to embed in the invoice.
@@ -13749,7 +14452,7 @@ export const ReceivePaymentMethod = (() => {
        * If empty, it is a Bitcoin payment
        */ tokenIdentifier: string | undefined;
       /**
-       * The expiry time of the invoice in seconds since the Unix epoch
+       * The expiry time of the invoice as a unix timestamp in seconds
        */ expiryTime: /*u64*/ bigint | undefined;
       /**
        * A description to embed in the invoice.
@@ -13818,7 +14521,7 @@ export const ReceivePaymentMethod = (() => {
       description: string;
       amountSats: /*u64*/ bigint | undefined;
       /**
-       * The expiry time of the invoice in seconds
+       * The expiry of the invoice as a duration in seconds
        */ expirySecs: /*u32*/ number | undefined;
     }) {
       super('ReceivePaymentMethod', 'Bolt11Invoice');
@@ -13829,7 +14532,7 @@ export const ReceivePaymentMethod = (() => {
       description: string;
       amountSats: /*u64*/ bigint | undefined;
       /**
-       * The expiry time of the invoice in seconds
+       * The expiry of the invoice as a duration in seconds
        */ expirySecs: /*u32*/ number | undefined;
     }): Bolt11Invoice_ {
       return new Bolt11Invoice_(inner);
@@ -17626,235 +18329,101 @@ export const SyncStorageError = (() => {
       return obj.tag === SyncStorageError_Tags.Serialization;
     }
 
-    static hasInner(obj: any): obj is Serialization_ {
-      return Serialization_.instanceOf(obj);
-    }
-
-    static getInner(obj: Serialization_): Readonly<[string]> {
-      return obj.inner;
-    }
-  }
-
-  function instanceOf(obj: any): obj is SyncStorageError {
-    return obj[uniffiTypeNameSymbol] === 'SyncStorageError';
-  }
-
-  return Object.freeze({
-    instanceOf,
-    Implementation: Implementation_,
-    InitializationError: InitializationError_,
-    Serialization: Serialization_,
-  });
-})();
-
-/**
- * Errors that can occur during storage operations
- */
-
-export type SyncStorageError = InstanceType<
-  (typeof SyncStorageError)[keyof Omit<typeof SyncStorageError, 'instanceOf'>]
->;
-
-// FfiConverter for enum SyncStorageError
-const FfiConverterTypeSyncStorageError = (() => {
-  const ordinalConverter = FfiConverterInt32;
-  type TypeName = SyncStorageError;
-  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-    read(from: RustBuffer): TypeName {
-      switch (ordinalConverter.read(from)) {
-        case 1:
-          return new SyncStorageError.Implementation(
-            FfiConverterString.read(from)
-          );
-        case 2:
-          return new SyncStorageError.InitializationError(
-            FfiConverterString.read(from)
-          );
-        case 3:
-          return new SyncStorageError.Serialization(
-            FfiConverterString.read(from)
-          );
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase();
-      }
-    }
-    write(value: TypeName, into: RustBuffer): void {
-      switch (value.tag) {
-        case SyncStorageError_Tags.Implementation: {
-          ordinalConverter.write(1, into);
-          const inner = value.inner;
-          FfiConverterString.write(inner[0], into);
-          return;
-        }
-        case SyncStorageError_Tags.InitializationError: {
-          ordinalConverter.write(2, into);
-          const inner = value.inner;
-          FfiConverterString.write(inner[0], into);
-          return;
-        }
-        case SyncStorageError_Tags.Serialization: {
-          ordinalConverter.write(3, into);
-          const inner = value.inner;
-          FfiConverterString.write(inner[0], into);
-          return;
-        }
-        default:
-          // Throwing from here means that SyncStorageError_Tags hasn't matched an ordinal.
-          throw new UniffiInternalError.UnexpectedEnumCase();
-      }
-    }
-    allocationSize(value: TypeName): number {
-      switch (value.tag) {
-        case SyncStorageError_Tags.Implementation: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(1);
-          size += FfiConverterString.allocationSize(inner[0]);
-          return size;
-        }
-        case SyncStorageError_Tags.InitializationError: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(2);
-          size += FfiConverterString.allocationSize(inner[0]);
-          return size;
-        }
-        case SyncStorageError_Tags.Serialization: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(3);
-          size += FfiConverterString.allocationSize(inner[0]);
-          return size;
-        }
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase();
-      }
-    }
-  }
-  return new FFIConverter();
-})();
-
-// Enum: TokenConversionType
-export enum TokenConversionType_Tags {
-  FromBitcoin = 'FromBitcoin',
-  ToBitcoin = 'ToBitcoin',
-}
-export const TokenConversionType = (() => {
-  type FromBitcoin__interface = {
-    tag: TokenConversionType_Tags.FromBitcoin;
-  };
-
-  /**
-   * Converting from Bitcoin to a token
-   */
-  class FromBitcoin_ extends UniffiEnum implements FromBitcoin__interface {
-    /**
-     * @private
-     * This field is private and should not be used, use `tag` instead.
-     */
-    readonly [uniffiTypeNameSymbol] = 'TokenConversionType';
-    readonly tag = TokenConversionType_Tags.FromBitcoin;
-    constructor() {
-      super('TokenConversionType', 'FromBitcoin');
-    }
-
-    static new(): FromBitcoin_ {
-      return new FromBitcoin_();
-    }
-
-    static instanceOf(obj: any): obj is FromBitcoin_ {
-      return obj.tag === TokenConversionType_Tags.FromBitcoin;
-    }
-  }
-
-  type ToBitcoin__interface = {
-    tag: TokenConversionType_Tags.ToBitcoin;
-    inner: Readonly<{ fromTokenIdentifier: string }>;
-  };
-
-  /**
-   * Converting from a token to Bitcoin
-   */
-  class ToBitcoin_ extends UniffiEnum implements ToBitcoin__interface {
-    /**
-     * @private
-     * This field is private and should not be used, use `tag` instead.
-     */
-    readonly [uniffiTypeNameSymbol] = 'TokenConversionType';
-    readonly tag = TokenConversionType_Tags.ToBitcoin;
-    readonly inner: Readonly<{ fromTokenIdentifier: string }>;
-    constructor(inner: { fromTokenIdentifier: string }) {
-      super('TokenConversionType', 'ToBitcoin');
-      this.inner = Object.freeze(inner);
-    }
-
-    static new(inner: { fromTokenIdentifier: string }): ToBitcoin_ {
-      return new ToBitcoin_(inner);
+    static hasInner(obj: any): obj is Serialization_ {
+      return Serialization_.instanceOf(obj);
     }
 
-    static instanceOf(obj: any): obj is ToBitcoin_ {
-      return obj.tag === TokenConversionType_Tags.ToBitcoin;
+    static getInner(obj: Serialization_): Readonly<[string]> {
+      return obj.inner;
     }
   }
 
-  function instanceOf(obj: any): obj is TokenConversionType {
-    return obj[uniffiTypeNameSymbol] === 'TokenConversionType';
+  function instanceOf(obj: any): obj is SyncStorageError {
+    return obj[uniffiTypeNameSymbol] === 'SyncStorageError';
   }
 
   return Object.freeze({
     instanceOf,
-    FromBitcoin: FromBitcoin_,
-    ToBitcoin: ToBitcoin_,
+    Implementation: Implementation_,
+    InitializationError: InitializationError_,
+    Serialization: Serialization_,
   });
 })();
 
-export type TokenConversionType = InstanceType<
-  (typeof TokenConversionType)[keyof Omit<
-    typeof TokenConversionType,
-    'instanceOf'
-  >]
+/**
+ * Errors that can occur during storage operations
+ */
+
+export type SyncStorageError = InstanceType<
+  (typeof SyncStorageError)[keyof Omit<typeof SyncStorageError, 'instanceOf'>]
 >;
 
-// FfiConverter for enum TokenConversionType
-const FfiConverterTypeTokenConversionType = (() => {
+// FfiConverter for enum SyncStorageError
+const FfiConverterTypeSyncStorageError = (() => {
   const ordinalConverter = FfiConverterInt32;
-  type TypeName = TokenConversionType;
+  type TypeName = SyncStorageError;
   class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
     read(from: RustBuffer): TypeName {
       switch (ordinalConverter.read(from)) {
         case 1:
-          return new TokenConversionType.FromBitcoin();
+          return new SyncStorageError.Implementation(
+            FfiConverterString.read(from)
+          );
         case 2:
-          return new TokenConversionType.ToBitcoin({
-            fromTokenIdentifier: FfiConverterString.read(from),
-          });
+          return new SyncStorageError.InitializationError(
+            FfiConverterString.read(from)
+          );
+        case 3:
+          return new SyncStorageError.Serialization(
+            FfiConverterString.read(from)
+          );
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
     write(value: TypeName, into: RustBuffer): void {
       switch (value.tag) {
-        case TokenConversionType_Tags.FromBitcoin: {
+        case SyncStorageError_Tags.Implementation: {
           ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner[0], into);
           return;
         }
-        case TokenConversionType_Tags.ToBitcoin: {
+        case SyncStorageError_Tags.InitializationError: {
           ordinalConverter.write(2, into);
           const inner = value.inner;
-          FfiConverterString.write(inner.fromTokenIdentifier, into);
+          FfiConverterString.write(inner[0], into);
+          return;
+        }
+        case SyncStorageError_Tags.Serialization: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner[0], into);
           return;
         }
         default:
-          // Throwing from here means that TokenConversionType_Tags hasn't matched an ordinal.
+          // Throwing from here means that SyncStorageError_Tags hasn't matched an ordinal.
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
     allocationSize(value: TypeName): number {
       switch (value.tag) {
-        case TokenConversionType_Tags.FromBitcoin: {
-          return ordinalConverter.allocationSize(1);
+        case SyncStorageError_Tags.Implementation: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner[0]);
+          return size;
         }
-        case TokenConversionType_Tags.ToBitcoin: {
+        case SyncStorageError_Tags.InitializationError: {
           const inner = value.inner;
           let size = ordinalConverter.allocationSize(2);
-          size += FfiConverterString.allocationSize(inner.fromTokenIdentifier);
+          size += FfiConverterString.allocationSize(inner[0]);
+          return size;
+        }
+        case SyncStorageError_Tags.Serialization: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner[0]);
           return size;
         }
         default:
@@ -18643,10 +19212,10 @@ export interface BreezSdkInterface {
    * Result containing either success or an `SdkError` if the background task couldn't be stopped
    */
   disconnect(asyncOpts_?: { signal: AbortSignal }): /*throws*/ Promise<void>;
-  fetchTokenConversionLimits(
-    request: FetchTokenConversionLimitsRequest,
+  fetchConversionLimits(
+    request: FetchConversionLimitsRequest,
     asyncOpts_?: { signal: AbortSignal }
-  ): /*throws*/ Promise<FetchTokenConversionLimitsResponse>;
+  ): /*throws*/ Promise<FetchConversionLimitsResponse>;
   /**
    * Returns the balance of the wallet in satoshis
    */
@@ -18726,6 +19295,59 @@ export interface BreezSdkInterface {
     request: ListUnclaimedDepositsRequest,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<ListUnclaimedDepositsResponse>;
+  /**
+   * Performs LNURL-auth with the service.
+   *
+   * This method implements the LNURL-auth protocol as specified in LUD-04 and LUD-05.
+   * It derives a domain-specific linking key, signs the challenge, and sends the
+   * authentication request to the service.
+   *
+   * # Arguments
+   *
+   * * `request_data` - The parsed LNURL-auth request details obtained from [`parse`]
+   *
+   * # Returns
+   *
+   * * `Ok(LnurlCallbackStatus::Ok)` - Authentication was successful
+   * * `Ok(LnurlCallbackStatus::ErrorStatus{reason})` - Service returned an error
+   * * `Err(SdkError)` - An error occurred during the authentication process
+   *
+   * # Example
+   *
+   * ```rust,no_run
+   * # use breez_sdk_spark::{BreezSdk, InputType};
+   * # async fn example(sdk: BreezSdk) -> Result<(), Box<dyn std::error::Error>> {
+   * // 1. Parse the LNURL-auth string
+   * let input = sdk.parse("lnurl1...").await?;
+   * let auth_request = match input {
+   * InputType::LnurlAuth(data) => data,
+   * _ => return Err("Not an auth request".into()),
+   * };
+   *
+   * // 2. Show user the domain and get confirmation
+   * println!("Authenticate with {}?", auth_request.domain);
+   *
+   * // 3. Perform authentication
+   * let status = sdk.lnurl_auth(auth_request).await?;
+   * match status {
+   * breez_sdk_spark::LnurlCallbackStatus::Ok => println!("Success!"),
+   * breez_sdk_spark::LnurlCallbackStatus::ErrorStatus { error_details } => {
+   * println!("Error: {}", error_details.reason)
+   * }
+   * }
+   * # Ok(())
+   * # }
+   * ```
+   *
+   * # See Also
+   *
+   * * LUD-04: <https://github.com/lnurl/luds/blob/luds/04.md>
+   * * LUD-05: <https://github.com/lnurl/luds/blob/luds/05.md>
+   */
+  lnurlAuth(
+    requestData: LnurlAuthRequestDetails,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<LnurlCallbackStatus>;
   lnurlPay(
     request: LnurlPayRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -19193,18 +19815,18 @@ export class BreezSdk
     }
   }
 
-  public async fetchTokenConversionLimits(
-    request: FetchTokenConversionLimitsRequest,
+  public async fetchConversionLimits(
+    request: FetchConversionLimitsRequest,
     asyncOpts_?: { signal: AbortSignal }
-  ): Promise<FetchTokenConversionLimitsResponse> /*throws*/ {
+  ): Promise<FetchConversionLimitsResponse> /*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_fetch_token_conversion_limits(
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_breezsdk_fetch_conversion_limits(
             uniffiTypeBreezSdkObjectFactory.clonePointer(this),
-            FfiConverterTypeFetchTokenConversionLimitsRequest.lower(request)
+            FfiConverterTypeFetchConversionLimitsRequest.lower(request)
           );
         },
         /*pollFunc:*/ nativeModule()
@@ -19215,8 +19837,8 @@ export class BreezSdk
           .ubrn_ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
         /*freeFunc:*/ nativeModule()
           .ubrn_ffi_breez_sdk_spark_rust_future_free_rust_buffer,
-        /*liftFunc:*/ FfiConverterTypeFetchTokenConversionLimitsResponse.lift.bind(
-          FfiConverterTypeFetchTokenConversionLimitsResponse
+        /*liftFunc:*/ FfiConverterTypeFetchConversionLimitsResponse.lift.bind(
+          FfiConverterTypeFetchConversionLimitsResponse
         ),
         /*liftString:*/ FfiConverterString.lift,
         /*asyncOpts:*/ asyncOpts_,
@@ -19648,6 +20270,94 @@ export class BreezSdk
     }
   }
 
+  /**
+   * Performs LNURL-auth with the service.
+   *
+   * This method implements the LNURL-auth protocol as specified in LUD-04 and LUD-05.
+   * It derives a domain-specific linking key, signs the challenge, and sends the
+   * authentication request to the service.
+   *
+   * # Arguments
+   *
+   * * `request_data` - The parsed LNURL-auth request details obtained from [`parse`]
+   *
+   * # Returns
+   *
+   * * `Ok(LnurlCallbackStatus::Ok)` - Authentication was successful
+   * * `Ok(LnurlCallbackStatus::ErrorStatus{reason})` - Service returned an error
+   * * `Err(SdkError)` - An error occurred during the authentication process
+   *
+   * # Example
+   *
+   * ```rust,no_run
+   * # use breez_sdk_spark::{BreezSdk, InputType};
+   * # async fn example(sdk: BreezSdk) -> Result<(), Box<dyn std::error::Error>> {
+   * // 1. Parse the LNURL-auth string
+   * let input = sdk.parse("lnurl1...").await?;
+   * let auth_request = match input {
+   * InputType::LnurlAuth(data) => data,
+   * _ => return Err("Not an auth request".into()),
+   * };
+   *
+   * // 2. Show user the domain and get confirmation
+   * println!("Authenticate with {}?", auth_request.domain);
+   *
+   * // 3. Perform authentication
+   * let status = sdk.lnurl_auth(auth_request).await?;
+   * match status {
+   * breez_sdk_spark::LnurlCallbackStatus::Ok => println!("Success!"),
+   * breez_sdk_spark::LnurlCallbackStatus::ErrorStatus { error_details } => {
+   * println!("Error: {}", error_details.reason)
+   * }
+   * }
+   * # Ok(())
+   * # }
+   * ```
+   *
+   * # See Also
+   *
+   * * LUD-04: <https://github.com/lnurl/luds/blob/luds/04.md>
+   * * LUD-05: <https://github.com/lnurl/luds/blob/luds/05.md>
+   */
+  public async lnurlAuth(
+    requestData: LnurlAuthRequestDetails,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<LnurlCallbackStatus> /*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_lnurl_auth(
+            uniffiTypeBreezSdkObjectFactory.clonePointer(this),
+            FfiConverterTypeLnurlAuthRequestDetails.lower(requestData)
+          );
+        },
+        /*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:*/ FfiConverterTypeLnurlCallbackStatus.lift.bind(
+          FfiConverterTypeLnurlCallbackStatus
+        ),
+        /*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 lnurlPay(
     request: LnurlPayRequest,
     asyncOpts_?: { signal: AbortSignal }
@@ -20376,30 +21086,34 @@ export interface ExternalSigner {
   /**
    * Signs a message using ECDSA at the given derivation path.
    *
+   * The message should be a 32-byte digest (typically a hash of the original data).
+   *
    * # Arguments
-   * * `message` - The message to sign
+   * * `message` - The 32-byte message digest to sign
    * * `path` - BIP32 derivation path as a string
    *
    * # Returns
    * 64-byte compact ECDSA signature, or a `SignerError`
    */
   signEcdsa(
-    message: ArrayBuffer,
+    message: MessageBytes,
     path: string,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<EcdsaSignatureBytes>;
   /**
    * Signs a message using recoverable ECDSA at the given derivation path.
    *
+   * The message should be a 32-byte digest (typically a hash of the original data).
+   *
    * # Arguments
-   * * `message` - The message to sign (will be double-SHA256 hashed)
+   * * `message` - The 32-byte message digest to sign
    * * `path` - BIP32 derivation path as a string
    *
    * # Returns
    * 65 bytes: recovery ID (31 + `recovery_id`) + 64-byte signature, or a `SignerError`
    */
   signEcdsaRecoverable(
-    message: ArrayBuffer,
+    message: MessageBytes,
     path: string,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<RecoverableEcdsaSignatureBytes>;
@@ -20448,6 +21162,21 @@ export interface ExternalSigner {
     path: string,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<SchnorrSignatureBytes>;
+  /**
+   * HMAC-SHA256 of a message at the given derivation path.
+   *
+   * # Arguments
+   * * `message` - The message to hash
+   * * `path` - BIP32 derivation path as a string
+   *
+   * # Returns
+   * 32-byte HMAC-SHA256, or a `SignerError`
+   */
+  hmacSha256(
+    message: ArrayBuffer,
+    path: string,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<HashedMessageBytes>;
   /**
    * Generates Frost signing commitments for multi-party signing.
    *
@@ -20705,15 +21434,17 @@ export class ExternalSignerImpl
   /**
    * Signs a message using ECDSA at the given derivation path.
    *
+   * The message should be a 32-byte digest (typically a hash of the original data).
+   *
    * # Arguments
-   * * `message` - The message to sign
+   * * `message` - The 32-byte message digest to sign
    * * `path` - BIP32 derivation path as a string
    *
    * # Returns
    * 64-byte compact ECDSA signature, or a `SignerError`
    */
   public async signEcdsa(
-    message: ArrayBuffer,
+    message: MessageBytes,
     path: string,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<EcdsaSignatureBytes> /*throws*/ {
@@ -20724,7 +21455,7 @@ export class ExternalSignerImpl
         /*rustFutureFunc:*/ () => {
           return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_externalsigner_sign_ecdsa(
             uniffiTypeExternalSignerImplObjectFactory.clonePointer(this),
-            FfiConverterArrayBuffer.lower(message),
+            FfiConverterTypeMessageBytes.lower(message),
             FfiConverterString.lower(path)
           );
         },
@@ -20756,15 +21487,17 @@ export class ExternalSignerImpl
   /**
    * Signs a message using recoverable ECDSA at the given derivation path.
    *
+   * The message should be a 32-byte digest (typically a hash of the original data).
+   *
    * # Arguments
-   * * `message` - The message to sign (will be double-SHA256 hashed)
+   * * `message` - The 32-byte message digest to sign
    * * `path` - BIP32 derivation path as a string
    *
    * # Returns
    * 65 bytes: recovery ID (31 + `recovery_id`) + 64-byte signature, or a `SignerError`
    */
   public async signEcdsaRecoverable(
-    message: ArrayBuffer,
+    message: MessageBytes,
     path: string,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<RecoverableEcdsaSignatureBytes> /*throws*/ {
@@ -20775,7 +21508,7 @@ export class ExternalSignerImpl
         /*rustFutureFunc:*/ () => {
           return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_externalsigner_sign_ecdsa_recoverable(
             uniffiTypeExternalSignerImplObjectFactory.clonePointer(this),
-            FfiConverterArrayBuffer.lower(message),
+            FfiConverterTypeMessageBytes.lower(message),
             FfiConverterString.lower(path)
           );
         },
@@ -20957,6 +21690,57 @@ export class ExternalSignerImpl
     }
   }
 
+  /**
+   * HMAC-SHA256 of a message at the given derivation path.
+   *
+   * # Arguments
+   * * `message` - The message to hash
+   * * `path` - BIP32 derivation path as a string
+   *
+   * # Returns
+   * 32-byte HMAC-SHA256, or a `SignerError`
+   */
+  public async hmacSha256(
+    message: ArrayBuffer,
+    path: string,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<HashedMessageBytes> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_breez_sdk_spark_fn_method_externalsigner_hmac_sha256(
+            uniffiTypeExternalSignerImplObjectFactory.clonePointer(this),
+            FfiConverterArrayBuffer.lower(message),
+            FfiConverterString.lower(path)
+          );
+        },
+        /*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:*/ FfiConverterTypeHashedMessageBytes.lift.bind(
+          FfiConverterTypeHashedMessageBytes
+        ),
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeSignerError.lift.bind(
+          FfiConverterTypeSignerError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   /**
    * Generates Frost signing commitments for multi-party signing.
    *
@@ -21714,7 +22498,7 @@ const uniffiCallbackInterfaceExternalSigner: {
       ): Promise<EcdsaSignatureBytes> => {
         const jsCallback = FfiConverterTypeExternalSigner.lift(uniffiHandle);
         return await jsCallback.signEcdsa(
-          FfiConverterArrayBuffer.lift(message),
+          FfiConverterTypeMessageBytes.lift(message),
           FfiConverterString.lift(path),
           { signal }
         );
@@ -21762,7 +22546,7 @@ const uniffiCallbackInterfaceExternalSigner: {
       ): Promise<RecoverableEcdsaSignatureBytes> => {
         const jsCallback = FfiConverterTypeExternalSigner.lift(uniffiHandle);
         return await jsCallback.signEcdsaRecoverable(
-          FfiConverterArrayBuffer.lift(message),
+          FfiConverterTypeMessageBytes.lift(message),
           FfiConverterString.lift(path),
           { signal }
         );
@@ -21946,6 +22730,54 @@ const uniffiCallbackInterfaceExternalSigner: {
       );
       return UniffiResult.success(uniffiForeignFuture);
     },
+    hmacSha256: (
+      uniffiHandle: bigint,
+      message: Uint8Array,
+      path: Uint8Array,
+      uniffiFutureCallback: UniffiForeignFutureCompleteRustBuffer,
+      uniffiCallbackData: bigint
+    ) => {
+      const uniffiMakeCall = async (
+        signal: AbortSignal
+      ): Promise<HashedMessageBytes> => {
+        const jsCallback = FfiConverterTypeExternalSigner.lift(uniffiHandle);
+        return await jsCallback.hmacSha256(
+          FfiConverterArrayBuffer.lift(message),
+          FfiConverterString.lift(path),
+          { signal }
+        );
+      };
+      const uniffiHandleSuccess = (returnValue: HashedMessageBytes) => {
+        uniffiFutureCallback(
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: FfiConverterTypeHashedMessageBytes.lower(returnValue),
+            callStatus: uniffiCaller.createCallStatus(),
+          }
+        );
+      };
+      const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+        uniffiFutureCallback(
+          uniffiCallbackData,
+          /* UniffiForeignFutureStructRustBuffer */ {
+            returnValue: /*empty*/ new Uint8Array(0),
+            // TODO create callstatus with error.
+            callStatus: { code, errorBuf },
+          }
+        );
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*isErrorType:*/ SignerError.instanceOf,
+        /*lowerError:*/ FfiConverterTypeSignerError.lower.bind(
+          FfiConverterTypeSignerError
+        ),
+        /*lowerString:*/ FfiConverterString.lower
+      );
+      return UniffiResult.success(uniffiForeignFuture);
+    },
     generateFrostSigningCommitments: (
       uniffiHandle: bigint,
       uniffiFutureCallback: UniffiForeignFutureCompleteRustBuffer,
@@ -27143,6 +27975,21 @@ const FfiConverterOptionalTypeLogger = new FfiConverterOptional(
   FfiConverterTypeLogger
 );
 
+// FfiConverter for ConversionEstimate | undefined
+const FfiConverterOptionalTypeConversionEstimate = new FfiConverterOptional(
+  FfiConverterTypeConversionEstimate
+);
+
+// FfiConverter for ConversionInfo | undefined
+const FfiConverterOptionalTypeConversionInfo = new FfiConverterOptional(
+  FfiConverterTypeConversionInfo
+);
+
+// FfiConverter for ConversionOptions | undefined
+const FfiConverterOptionalTypeConversionOptions = new FfiConverterOptional(
+  FfiConverterTypeConversionOptions
+);
+
 // FfiConverter for Credentials | undefined
 const FfiConverterOptionalTypeCredentials = new FfiConverterOptional(
   FfiConverterTypeCredentials
@@ -27207,16 +28054,6 @@ const FfiConverterOptionalTypeSymbol = new FfiConverterOptional(
   FfiConverterTypeSymbol
 );
 
-// FfiConverter for TokenConversionInfo | undefined
-const FfiConverterOptionalTypeTokenConversionInfo = new FfiConverterOptional(
-  FfiConverterTypeTokenConversionInfo
-);
-
-// FfiConverter for TokenConversionOptions | undefined
-const FfiConverterOptionalTypeTokenConversionOptions = new FfiConverterOptional(
-  FfiConverterTypeTokenConversionOptions
-);
-
 // FfiConverter for string | undefined
 const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
 
@@ -27354,6 +28191,11 @@ const FfiConverterOptionalTypeAssetFilter = new FfiConverterOptional(
   FfiConverterTypeAssetFilter
 );
 
+// FfiConverter for ConversionPurpose | undefined
+const FfiConverterOptionalTypeConversionPurpose = new FfiConverterOptional(
+  FfiConverterTypeConversionPurpose
+);
+
 // FfiConverter for DepositClaimError | undefined
 const FfiConverterOptionalTypeDepositClaimError = new FfiConverterOptional(
   FfiConverterTypeDepositClaimError
@@ -27608,11 +28450,11 @@ function uniffiEnsureInitialized() {
     );
   }
   if (
-    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_token_conversion_limits() !==
-    9413
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_conversion_limits() !==
+    50958
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
-      'uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_token_conversion_limits'
+      'uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_conversion_limits'
     );
   }
   if (
@@ -27703,6 +28545,14 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_breezsdk_list_unclaimed_deposits'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_auth() !==
+    37942
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_auth'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_pay() !==
     10147
@@ -27841,7 +28691,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa() !==
-    52291
+    37648
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa'
@@ -27849,7 +28699,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa_recoverable() !==
-    8564
+    3107
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa_recoverable'
@@ -27879,9 +28729,17 @@ function uniffiEnsureInitialized() {
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_hash_schnorr'
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_hmac_sha256() !==
+    19799
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      'uniffi_breez_sdk_spark_checksum_method_externalsigner_hmac_sha256'
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_frost_signing_commitments() !==
-    24826
+    24833
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_frost_signing_commitments'
@@ -27889,7 +28747,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_for_node() !==
-    32818
+    62425
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_for_node'
@@ -27897,7 +28755,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_key() !==
-    22789
+    21363
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_key'
@@ -27905,7 +28763,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key_source() !==
-    37751
+    61352
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key_source'
@@ -27913,7 +28771,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key() !==
-    55375
+    57038
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key'
@@ -27921,7 +28779,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_public_key() !==
-    49264
+    47081
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_public_key'
@@ -27929,7 +28787,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_subtract_private_keys() !==
-    46671
+    63060
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_subtract_private_keys'
@@ -27937,7 +28795,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_split_secret() !==
-    840
+    22937
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_split_secret'
@@ -27945,7 +28803,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_private_key_for_receiver() !==
-    42476
+    52786
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_private_key_for_receiver'
@@ -27953,7 +28811,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_from_private_key_source() !==
-    38684
+    58178
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_from_private_key_source'
@@ -27961,7 +28819,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_frost() !==
-    1497
+    44847
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_frost'
@@ -27969,7 +28827,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigner_aggregate_frost_signatures() !==
-    26523
+    61746
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_breez_sdk_spark_checksum_method_externalsigner_aggregate_frost_signatures'
@@ -28415,6 +29273,12 @@ export default Object.freeze({
     FfiConverterTypeConfig,
     FfiConverterTypeConnectRequest,
     FfiConverterTypeConnectWithSignerRequest,
+    FfiConverterTypeConversionEstimate,
+    FfiConverterTypeConversionInfo,
+    FfiConverterTypeConversionOptions,
+    FfiConverterTypeConversionPurpose,
+    FfiConverterTypeConversionStatus,
+    FfiConverterTypeConversionType,
     FfiConverterTypeCreateIssuerTokenRequest,
     FfiConverterTypeCredentials,
     FfiConverterTypeCurrencyInfo,
@@ -28438,8 +29302,8 @@ export default Object.freeze({
     FfiConverterTypeExternalTreeNodeId,
     FfiConverterTypeExternalVerifiableSecretShare,
     FfiConverterTypeFee,
-    FfiConverterTypeFetchTokenConversionLimitsRequest,
-    FfiConverterTypeFetchTokenConversionLimitsResponse,
+    FfiConverterTypeFetchConversionLimitsRequest,
+    FfiConverterTypeFetchConversionLimitsResponse,
     FfiConverterTypeFiatCurrency,
     FfiConverterTypeFiatService,
     FfiConverterTypeFreezeIssuerTokenRequest,
@@ -28450,6 +29314,7 @@ export default Object.freeze({
     FfiConverterTypeGetPaymentResponse,
     FfiConverterTypeGetTokensMetadataRequest,
     FfiConverterTypeGetTokensMetadataResponse,
+    FfiConverterTypeHashedMessageBytes,
     FfiConverterTypeIdentifierCommitmentPair,
     FfiConverterTypeIdentifierPublicKeyPair,
     FfiConverterTypeIdentifierSignaturePair,
@@ -28466,6 +29331,8 @@ export default Object.freeze({
     FfiConverterTypeListUnclaimedDepositsRequest,
     FfiConverterTypeListUnclaimedDepositsResponse,
     FfiConverterTypeLnurlAuthRequestDetails,
+    FfiConverterTypeLnurlCallbackStatus,
+    FfiConverterTypeLnurlErrorDetails,
     FfiConverterTypeLnurlPayInfo,
     FfiConverterTypeLnurlPayRequest,
     FfiConverterTypeLnurlPayRequestDetails,
@@ -28479,6 +29346,7 @@ export default Object.freeze({
     FfiConverterTypeLocalizedName,
     FfiConverterTypeLogEntry,
     FfiConverterTypeMaxFee,
+    FfiConverterTypeMessageBytes,
     FfiConverterTypeMessageSuccessActionData,
     FfiConverterTypeMintIssuerTokenRequest,
     FfiConverterTypeNetwork,
@@ -28546,9 +29414,6 @@ export default Object.freeze({
     FfiConverterTypeSyncWalletRequest,
     FfiConverterTypeSyncWalletResponse,
     FfiConverterTypeTokenBalance,
-    FfiConverterTypeTokenConversionInfo,
-    FfiConverterTypeTokenConversionOptions,
-    FfiConverterTypeTokenConversionType,
     FfiConverterTypeTokenIssuer,
     FfiConverterTypeTokenMetadata,
     FfiConverterTypeTxStatus,