breez-sdk-spark 0.7.0.dev1__cp310-cp310-manylinux_2_31_x86_64.whl → 0.7.10__cp310-cp310-manylinux_2_31_x86_64.whl

breez_sdk_spark/breez_sdk_spark.py

@@ -497,7 +497,7 @@ def _uniffi_check_api_checksums(lib):
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_disconnect() != 330:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_token_conversion_limits() != 9413:
+    if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_conversion_limits() != 50958:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_get_info() != 6771:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
@@ -521,6 +521,8 @@ def _uniffi_check_api_checksums(lib):
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_list_unclaimed_deposits() != 22486:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_auth() != 37942:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_pay() != 10147:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_withdraw() != 45652:
@@ -551,43 +553,45 @@ def _uniffi_check_api_checksums(lib):
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_breez_sdk_spark_checksum_method_breezsdk_update_user_settings() != 1721:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_identity_public_key() != 44711:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_identity_public_key() != 62941:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_derive_public_key() != 63908:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_derive_public_key() != 23137:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa() != 52291:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa() != 37648:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa_recoverable() != 8564:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa_recoverable() != 3107:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_ecies_encrypt() != 19449:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_ecies() != 60224:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_ecies_decrypt() != 46414:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_decrypt_ecies() != 59601:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_hash_schnorr() != 57220:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_frost_signing_commitments() != 24826:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_hmac_sha256() != 57517:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_signing_commitment() != 31862:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_for_node() != 32818:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_for_node() != 37434:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_key() != 22789:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_secret() != 26114:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key_source() != 37751:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_secret_encrypted() != 38925:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key() != 55375:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_secret() != 45280:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_public_key() != 49264:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_signing_key() != 62519:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_subtract_private_keys() != 46671:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_subtract_secrets() != 51106:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_split_secret() != 840:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_split_secret_with_proofs() != 19489:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_private_key_for_receiver() != 42476:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_secret_for_receiver() != 51627:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_from_private_key_source() != 38684:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_public_key_from_secret() != 53055:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_frost() != 1497:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_frost() != 20635:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
-    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_aggregate_frost_signatures() != 26523:
+    if lib.uniffi_breez_sdk_spark_checksum_method_externalsigner_aggregate_frost() != 53544:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_breez_sdk_spark_checksum_method_fiatservice_fetch_fiat_currencies() != 19092:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
@@ -823,30 +827,32 @@ _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD5 = ctypes.CFUNCTYPE(None,ctype
 )
 _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD6 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
-_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD7 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD7 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
-_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD8 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD8 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
-_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD9 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD9 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
-_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD10 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_uint32,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD10 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
 _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD11 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_uint32,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
 _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD12 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_uint32,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
-_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD13 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD13 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_uint32,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
-_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD14 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,ctypes.c_uint32,ctypes.c_uint32,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD14 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
-_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD15 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD15 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,ctypes.c_uint32,ctypes.c_uint32,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
-_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD16 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD16 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
 _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD17 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
 _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD18 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
+_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD19 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiRustBuffer,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
+)
 _UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD0 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
 )
 _UNIFFI_CALLBACK_INTERFACE_FIAT_SERVICE_METHOD1 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER,ctypes.c_uint64,ctypes.POINTER(_UniffiForeignFuture),
@@ -930,21 +936,22 @@ class _UniffiVTableCallbackInterfaceExternalSigner(ctypes.Structure):
         ("derive_public_key", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD1),
         ("sign_ecdsa", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD2),
         ("sign_ecdsa_recoverable", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD3),
-        ("ecies_encrypt", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD4),
-        ("ecies_decrypt", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD5),
+        ("encrypt_ecies", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD4),
+        ("decrypt_ecies", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD5),
         ("sign_hash_schnorr", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD6),
-        ("generate_frost_signing_commitments", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD7),
-        ("get_public_key_for_node", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD8),
-        ("generate_random_key", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD9),
-        ("get_static_deposit_private_key_source", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD10),
-        ("get_static_deposit_private_key", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD11),
-        ("get_static_deposit_public_key", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD12),
-        ("subtract_private_keys", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD13),
-        ("split_secret", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD14),
-        ("encrypt_private_key_for_receiver", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD15),
-        ("get_public_key_from_private_key_source", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD16),
-        ("sign_frost", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD17),
-        ("aggregate_frost_signatures", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD18),
+        ("hmac_sha256", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD7),
+        ("generate_random_signing_commitment", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD8),
+        ("get_public_key_for_node", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD9),
+        ("generate_random_secret", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD10),
+        ("static_deposit_secret_encrypted", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD11),
+        ("static_deposit_secret", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD12),
+        ("static_deposit_signing_key", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD13),
+        ("subtract_secrets", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD14),
+        ("split_secret_with_proofs", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD15),
+        ("encrypt_secret_for_receiver", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD16),
+        ("public_key_from_secret", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD17),
+        ("sign_frost", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD18),
+        ("aggregate_frost", _UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD19),
         ("uniffi_free", _UNIFFI_CALLBACK_INTERFACE_FREE),
     ]
 class _UniffiVTableCallbackInterfaceFiatService(ctypes.Structure):
@@ -1081,11 +1088,11 @@ _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_disconnect.argtypes = (
     ctypes.c_void_p,
 )
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_disconnect.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_fetch_token_conversion_limits.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_fetch_conversion_limits.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_fetch_token_conversion_limits.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_fetch_conversion_limits.restype = ctypes.c_uint64
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_get_info.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
@@ -1137,6 +1144,11 @@ _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_list_unclaimed_deposits.arg
     _UniffiRustBuffer,
 )
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_list_unclaimed_deposits.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_lnurl_auth.argtypes = (
+    ctypes.c_void_p,
+    _UniffiRustBuffer,
+)
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_lnurl_auth.restype = ctypes.c_uint64
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_lnurl_pay.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
@@ -1247,86 +1259,92 @@ _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_sign_ecdsa_recoverabl
     _UniffiRustBuffer,
 )
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_sign_ecdsa_recoverable.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_ecies_encrypt.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_ecies.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_ecies_encrypt.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_ecies_decrypt.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_ecies.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_decrypt_ecies.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_ecies_decrypt.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_decrypt_ecies.restype = ctypes.c_uint64
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_sign_hash_schnorr.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
     _UniffiRustBuffer,
 )
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_sign_hash_schnorr.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_frost_signing_commitments.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_hmac_sha256.argtypes = (
+    ctypes.c_void_p,
+    _UniffiRustBuffer,
+    _UniffiRustBuffer,
+)
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_hmac_sha256.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_signing_commitment.argtypes = (
     ctypes.c_void_p,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_frost_signing_commitments.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_signing_commitment.restype = ctypes.c_uint64
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_public_key_for_node.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
 )
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_public_key_for_node.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_key.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_secret.argtypes = (
     ctypes.c_void_p,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_key.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_private_key_source.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_secret.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_secret_encrypted.argtypes = (
     ctypes.c_void_p,
     ctypes.c_uint32,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_private_key_source.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_private_key.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_secret_encrypted.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_secret.argtypes = (
     ctypes.c_void_p,
     ctypes.c_uint32,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_private_key.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_public_key.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_secret.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_signing_key.argtypes = (
     ctypes.c_void_p,
     ctypes.c_uint32,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_public_key.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_subtract_private_keys.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_signing_key.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_subtract_secrets.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_subtract_private_keys.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_split_secret.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_subtract_secrets.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_split_secret_with_proofs.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
     ctypes.c_uint32,
     ctypes.c_uint32,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_split_secret.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_private_key_for_receiver.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_split_secret_with_proofs.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_secret_for_receiver.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_private_key_for_receiver.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_public_key_from_private_key_source.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_secret_for_receiver.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_public_key_from_secret.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_public_key_from_private_key_source.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_public_key_from_secret.restype = ctypes.c_uint64
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_sign_frost.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
 )
 _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_sign_frost.restype = ctypes.c_uint64
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_aggregate_frost_signatures.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_aggregate_frost.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
 )
-_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_aggregate_frost_signatures.restype = ctypes.c_uint64
+_UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_aggregate_frost.restype = ctypes.c_uint64
 _UniffiLib.uniffi_breez_sdk_spark_fn_clone_fiatservice.argtypes = (
     ctypes.c_void_p,
     ctypes.POINTER(_UniffiRustCallStatus),
@@ -2017,9 +2035,9 @@ _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_delete_lightning_addr
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_disconnect.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_disconnect.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_token_conversion_limits.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_conversion_limits.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_token_conversion_limits.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_fetch_conversion_limits.restype = ctypes.c_uint16
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_get_info.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_get_info.restype = ctypes.c_uint16
@@ -2053,6 +2071,9 @@ _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_list_payments.restype
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_list_unclaimed_deposits.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_list_unclaimed_deposits.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_auth.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_auth.restype = ctypes.c_uint16
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_pay.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_breezsdk_lnurl_pay.restype = ctypes.c_uint16
@@ -2110,51 +2131,54 @@ _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa.rest
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa_recoverable.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_ecdsa_recoverable.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_ecies_encrypt.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_ecies.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_ecies_encrypt.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_ecies_decrypt.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_ecies.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_decrypt_ecies.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_ecies_decrypt.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_decrypt_ecies.restype = ctypes.c_uint16
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_hash_schnorr.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_hash_schnorr.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_frost_signing_commitments.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_hmac_sha256.argtypes = (
+)
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_hmac_sha256.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_signing_commitment.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_frost_signing_commitments.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_signing_commitment.restype = ctypes.c_uint16
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_for_node.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_for_node.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_key.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_secret.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_key.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key_source.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_generate_random_secret.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_secret_encrypted.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key_source.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_secret_encrypted.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_secret.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_private_key.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_public_key.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_secret.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_signing_key.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_static_deposit_public_key.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_subtract_private_keys.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_static_deposit_signing_key.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_subtract_secrets.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_subtract_private_keys.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_split_secret.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_subtract_secrets.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_split_secret_with_proofs.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_split_secret.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_private_key_for_receiver.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_split_secret_with_proofs.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_secret_for_receiver.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_private_key_for_receiver.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_from_private_key_source.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_encrypt_secret_for_receiver.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_public_key_from_secret.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_get_public_key_from_private_key_source.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_public_key_from_secret.restype = ctypes.c_uint16
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_frost.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_sign_frost.restype = ctypes.c_uint16
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_aggregate_frost_signatures.argtypes = (
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_aggregate_frost.argtypes = (
 )
-_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_aggregate_frost_signatures.restype = ctypes.c_uint16
+_UniffiLib.uniffi_breez_sdk_spark_checksum_method_externalsigner_aggregate_frost.restype = ctypes.c_uint16
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_fiatservice_fetch_fiat_currencies.argtypes = (
 )
 _UniffiLib.uniffi_breez_sdk_spark_checksum_method_fiatservice_fetch_fiat_currencies.restype = ctypes.c_uint16
@@ -2901,7 +2925,7 @@ class BreezSdkProtocol(typing.Protocol):
         """
 
         raise NotImplementedError
-    def fetch_token_conversion_limits(self, request: "FetchTokenConversionLimitsRequest"):
+    def fetch_conversion_limits(self, request: "FetchConversionLimitsRequest"):
         raise NotImplementedError
     def get_info(self, request: "GetInfoRequest"):
         """
@@ -2977,6 +3001,58 @@ class BreezSdkProtocol(typing.Protocol):
 
         raise NotImplementedError
     def list_unclaimed_deposits(self, request: "ListUnclaimedDepositsRequest"):
+        raise NotImplementedError
+    def lnurl_auth(self, request_data: "LnurlAuthRequestDetails"):
+        """
+        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>
+        """
+
         raise NotImplementedError
     def lnurl_pay(self, request: "LnurlPayRequest"):
         raise NotImplementedError
@@ -3313,19 +3389,19 @@ _UniffiConverterTypeSdkError,
 
 
 
-    async def fetch_token_conversion_limits(self, request: "FetchTokenConversionLimitsRequest") -> "FetchTokenConversionLimitsResponse":
-        _UniffiConverterTypeFetchTokenConversionLimitsRequest.check_lower(request)
+    async def fetch_conversion_limits(self, request: "FetchConversionLimitsRequest") -> "FetchConversionLimitsResponse":
+        _UniffiConverterTypeFetchConversionLimitsRequest.check_lower(request)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_fetch_token_conversion_limits(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_fetch_conversion_limits(
                 self._uniffi_clone_pointer(), 
-        _UniffiConverterTypeFetchTokenConversionLimitsRequest.lower(request)
+        _UniffiConverterTypeFetchConversionLimitsRequest.lower(request)
             ),
             _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_free_rust_buffer,
             # lift function
-            _UniffiConverterTypeFetchTokenConversionLimitsResponse.lift,
+            _UniffiConverterTypeFetchConversionLimitsResponse.lift,
             
     # Error FFI converter
 _UniffiConverterTypeSdkError,
@@ -3582,6 +3658,77 @@ _UniffiConverterTypeSdkError,
 
 
 
+    async def lnurl_auth(self, request_data: "LnurlAuthRequestDetails") -> "LnurlCallbackStatus":
+        """
+        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>
+        """
+
+        _UniffiConverterTypeLnurlAuthRequestDetails.check_lower(request_data)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_breezsdk_lnurl_auth(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterTypeLnurlAuthRequestDetails.lower(request_data)
+            ),
+            _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+            # lift function
+            _UniffiConverterTypeLnurlCallbackStatus.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeSdkError,
+
+        )
+
+
+
     async def lnurl_pay(self, request: "LnurlPayRequest") -> "LnurlPayResponse":
         _UniffiConverterTypeLnurlPayRequest.check_lower(request)
         
@@ -4002,6 +4149,8 @@ class ExternalSigner(typing.Protocol):
     def identity_public_key(self, ):
         """
         Returns the identity public key as 33 bytes (compressed secp256k1 key).
+
+        See also: [JavaScript `getIdentityPublicKey`](https://docs.spark.money/wallets/spark-signer#get-identity-public-key)
         """
 
         raise NotImplementedError
@@ -4014,15 +4163,19 @@ class ExternalSigner(typing.Protocol):
 
         # Returns
         The derived public key as 33 bytes, or a `SignerError`
+
+        See also: [JavaScript `getPublicKeyFromDerivation`](https://docs.spark.money/wallets/spark-signer#get-public-key-from-derivation)
         """
 
         raise NotImplementedError
-    def sign_ecdsa(self, message: "bytes",path: "str"):
+    def sign_ecdsa(self, message: "MessageBytes",path: "str"):
         """
         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
@@ -4030,12 +4183,14 @@ class ExternalSigner(typing.Protocol):
         """
 
         raise NotImplementedError
-    def sign_ecdsa_recoverable(self, message: "bytes",path: "str"):
+    def sign_ecdsa_recoverable(self, message: "MessageBytes",path: "str"):
         """
         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
@@ -4043,7 +4198,7 @@ class ExternalSigner(typing.Protocol):
         """
 
         raise NotImplementedError
-    def ecies_encrypt(self, message: "bytes",path: "str"):
+    def encrypt_ecies(self, message: "bytes",path: "str"):
         """
         Encrypts a message using ECIES at the given derivation path.
 
@@ -4056,7 +4211,7 @@ class ExternalSigner(typing.Protocol):
         """
 
         raise NotImplementedError
-    def ecies_decrypt(self, message: "bytes",path: "str"):
+    def decrypt_ecies(self, message: "bytes",path: "str"):
         """
         Decrypts a message using ECIES at the given derivation path.
 
@@ -4066,6 +4221,8 @@ class ExternalSigner(typing.Protocol):
 
         # Returns
         Decrypted data, or a `SignerError`
+
+        See also: [JavaScript `decryptEcies`](https://docs.spark.money/wallets/spark-signer#decrypt-ecies)
         """
 
         raise NotImplementedError
@@ -4082,12 +4239,29 @@ class ExternalSigner(typing.Protocol):
         """
 
         raise NotImplementedError
-    def generate_frost_signing_commitments(self, ):
+    def hmac_sha256(self, message: "bytes",path: "str"):
+        """
+        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`
+
+        See also: [JavaScript `htlcHMAC`](https://docs.spark.money/wallets/spark-signer#generate-htlc-hmac)
+        """
+
+        raise NotImplementedError
+    def generate_random_signing_commitment(self, ):
         """
         Generates Frost signing commitments for multi-party signing.
 
         # Returns
         Frost commitments with nonces, or a `SignerError`
+
+        See also: [JavaScript `getRandomSigningCommitment`](https://docs.spark.money/wallets/spark-signer#get-random-signing-commitment)
         """
 
         raise NotImplementedError
@@ -4099,69 +4273,91 @@ class ExternalSigner(typing.Protocol):
         * `id` - The tree node identifier
 
         # Returns
-        The public key for the node, or an error string
+        The public key for the node, or a `SignerError`
         """
 
         raise NotImplementedError
-    def generate_random_key(self, ):
+    def generate_random_secret(self, ):
         """
-        Generates a random private key.
+        Generates a random secret that is encrypted and known only to the signer.
+
+        This method creates a new random secret and returns it in encrypted form.
+        The plaintext secret never leaves the signer boundary, providing a secure way
+        to create secrets that can be referenced in subsequent operations without
+        exposing them.
+
+        This is conceptually similar to Spark's key derivation system where secrets
+        are represented by opaque references (like tree node IDs or Random) rather than raw values.
+        The encrypted secret can be passed to other signer methods that need to operate
+        on it, while keeping the actual secret material protected within the signer.
 
         # Returns
-        A randomly generated private key source, or an error string
+        An encrypted secret that can be used in subsequent signer operations,
+        or a `SignerError` if generation fails.
+
+        See also: [Key Derivation System](https://docs.spark.money/wallets/spark-signer#the-keyderivation-system)
         """
 
         raise NotImplementedError
-    def get_static_deposit_private_key_source(self, index: "int"):
+    def static_deposit_secret_encrypted(self, index: "int"):
         """
-        Gets a static deposit private key source by index.
+        Gets an encrypted static deposit secret by index.
 
         # Arguments
-        * `index` - The index of the static deposit key
+        * `index` - The index of the static deposit secret
 
         # Returns
-        The private key source, or an error string
+        The encrypted secret, or a `SignerError`
+
+        This is the encrypted version of: [JavaScript `getStaticDepositSecretKey`](https://docs.spark.money/wallets/spark-signer#get-static-deposit-secret-key)
         """
 
         raise NotImplementedError
-    def get_static_deposit_private_key(self, index: "int"):
+    def static_deposit_secret(self, index: "int"):
         """
-        Gets a static deposit private key by index.
+        Gets a static deposit secret by index.
 
         # Arguments
-        * `index` - The index of the static deposit key
+        * `index` - The index of the static deposit secret
 
         # Returns
-        The 32-byte private key, or an error string
+        The 32-byte secret, or a `SignerError`
+
+        See also: [JavaScript `getStaticDepositSecretKey`](https://docs.spark.money/wallets/spark-signer#get-static-deposit-secret-key)
         """
 
         raise NotImplementedError
-    def get_static_deposit_public_key(self, index: "int"):
+    def static_deposit_signing_key(self, index: "int"):
         """
-        Gets a static deposit public key by index.
+        Gets a static deposit signing public key by index.
 
         # Arguments
-        * `index` - The index of the static deposit key
+        * `index` - The index of the static deposit public signing key
 
         # Returns
-        The 33-byte public key, or an error string
+        The 33-byte public key, or a `SignerError`
+
+        See also: [JavaScript `getStaticDepositSigningKey`](https://docs.spark.money/wallets/spark-signer#get-static-deposit-signing-key)
         """
 
         raise NotImplementedError
-    def subtract_private_keys(self, signing_key: "ExternalPrivateKeySource",new_signing_key: "ExternalPrivateKeySource"):
+    def subtract_secrets(self, signing_key: "ExternalSecretSource",new_signing_key: "ExternalSecretSource"):
         """
-        Subtracts one private key from another.
+        Subtracts one secret from another.
 
         # Arguments
-        * `signing_key` - The first private key source
-        * `new_signing_key` - The second private key source to subtract
+        * `signing_key` - The first secret
+        * `new_signing_key` - The second secret to subtract
 
         # Returns
-        The resulting private key source, or an error string
+        The resulting secret, or a `SignerError`
+
+        See also: [JavaScript `subtractSplitAndEncrypt`](https://docs.spark.money/wallets/spark-signer#subtract,-split,-and-encrypt)
+        (this method provides the subtraction step of that higher-level operation)
         """
 
         raise NotImplementedError
-    def split_secret(self, secret: "ExternalSecretToSplit",threshold: "int",num_shares: "int"):
+    def split_secret_with_proofs(self, secret: "ExternalSecretToSplit",threshold: "int",num_shares: "int"):
         """
         Splits a secret with proofs using Shamir's Secret Sharing.
 
@@ -4171,32 +4367,36 @@ class ExternalSigner(typing.Protocol):
         * `num_shares` - Total number of shares to create
 
         # Returns
-        Vector of verifiable secret shares, or an error string
+        Vector of verifiable secret shares, or a `SignerError`
+
+        See also: [JavaScript `splitSecretWithProofs`](https://docs.spark.money/wallets/spark-signer#split-secret-with-proofs)
         """
 
         raise NotImplementedError
-    def encrypt_private_key_for_receiver(self, private_key: "ExternalEncryptedPrivateKey",receiver_public_key: "PublicKeyBytes"):
+    def encrypt_secret_for_receiver(self, encrypted_secret: "ExternalEncryptedSecret",receiver_public_key: "PublicKeyBytes"):
         """
-        Encrypts a private key for a specific receiver's public key.
+        Encrypts a secret for a specific receiver's public key.
 
         # Arguments
-        * `private_key` - The encrypted private key to re-encrypt
+        * `encrypted_secret` - The encrypted secret to re-encrypt
         * `receiver_public_key` - The receiver's 33-byte public key
 
         # Returns
-        Encrypted data for the receiver, or an error string
+        Encrypted data for the receiver, or a `SignerError`
         """
 
         raise NotImplementedError
-    def get_public_key_from_private_key_source(self, private_key: "ExternalPrivateKeySource"):
+    def public_key_from_secret(self, secret: "ExternalSecretSource"):
         """
-        Gets the public key from a private key source.
+        Gets the public key from a secret.
 
         # Arguments
-        * `private_key` - The private key source
+        * `secret` - The secret
 
         # Returns
-        The corresponding 33-byte public key, or an error string
+        The corresponding 33-byte public key, or a `SignerError`
+
+        See also: [JavaScript `getPublicKeyFromDerivation`](https://docs.spark.money/wallets/spark-signer#get-public-key-from-derivation)
         """
 
         raise NotImplementedError
@@ -4208,11 +4408,13 @@ class ExternalSigner(typing.Protocol):
         * `request` - The Frost signing request
 
         # Returns
-        A signature share, or an error string
+        A signature share, or a `SignerError`
+
+        See also: [JavaScript `signFrost`](https://docs.spark.money/wallets/spark-signer#frost-signing)
         """
 
         raise NotImplementedError
-    def aggregate_frost_signatures(self, request: "ExternalAggregateFrostRequest"):
+    def aggregate_frost(self, request: "ExternalAggregateFrostRequest"):
         """
         Aggregates Frost signature shares into a final signature.
 
@@ -4220,7 +4422,9 @@ class ExternalSigner(typing.Protocol):
         * `request` - The Frost aggregation request
 
         # Returns
-        The aggregated Frost signature, or an error string
+        The aggregated Frost signature, or a `SignerError`
+
+        See also: [JavaScript `aggregateFrost`](https://docs.spark.money/wallets/spark-signer#aggregate-frost-signatures)
         """
 
         raise NotImplementedError
@@ -4268,6 +4472,8 @@ class ExternalSignerImpl:
     def identity_public_key(self, ) -> "PublicKeyBytes":
         """
         Returns the identity public key as 33 bytes (compressed secp256k1 key).
+
+        See also: [JavaScript `getIdentityPublicKey`](https://docs.spark.money/wallets/spark-signer#get-identity-public-key)
         """
 
         return _UniffiConverterTypePublicKeyBytes.lift(
@@ -4286,6 +4492,8 @@ class ExternalSignerImpl:
 
         # Returns
         The derived public key as 33 bytes, or a `SignerError`
+
+        See also: [JavaScript `getPublicKeyFromDerivation`](https://docs.spark.money/wallets/spark-signer#get-public-key-from-derivation)
         """
 
         _UniffiConverterString.check_lower(path)
@@ -4308,26 +4516,28 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def sign_ecdsa(self, message: "bytes",path: "str") -> "EcdsaSignatureBytes":
+    async def sign_ecdsa(self, message: "MessageBytes",path: "str") -> "EcdsaSignatureBytes":
         """
         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`
         """
 
-        _UniffiConverterBytes.check_lower(message)
+        _UniffiConverterTypeMessageBytes.check_lower(message)
         
         _UniffiConverterString.check_lower(path)
         
         return await _uniffi_rust_call_async(
             _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_sign_ecdsa(
                 self._uniffi_clone_pointer(), 
-        _UniffiConverterBytes.lower(message),
+        _UniffiConverterTypeMessageBytes.lower(message),
         _UniffiConverterString.lower(path)
             ),
             _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
@@ -4343,26 +4553,28 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def sign_ecdsa_recoverable(self, message: "bytes",path: "str") -> "RecoverableEcdsaSignatureBytes":
+    async def sign_ecdsa_recoverable(self, message: "MessageBytes",path: "str") -> "RecoverableEcdsaSignatureBytes":
         """
         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`
         """
 
-        _UniffiConverterBytes.check_lower(message)
+        _UniffiConverterTypeMessageBytes.check_lower(message)
         
         _UniffiConverterString.check_lower(path)
         
         return await _uniffi_rust_call_async(
             _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_sign_ecdsa_recoverable(
                 self._uniffi_clone_pointer(), 
-        _UniffiConverterBytes.lower(message),
+        _UniffiConverterTypeMessageBytes.lower(message),
         _UniffiConverterString.lower(path)
             ),
             _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
@@ -4378,7 +4590,7 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def ecies_encrypt(self, message: "bytes",path: "str") -> "bytes":
+    async def encrypt_ecies(self, message: "bytes",path: "str") -> "bytes":
         """
         Encrypts a message using ECIES at the given derivation path.
 
@@ -4395,7 +4607,7 @@ _UniffiConverterTypeSignerError,
         _UniffiConverterString.check_lower(path)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_ecies_encrypt(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_ecies(
                 self._uniffi_clone_pointer(), 
         _UniffiConverterBytes.lower(message),
         _UniffiConverterString.lower(path)
@@ -4413,7 +4625,7 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def ecies_decrypt(self, message: "bytes",path: "str") -> "bytes":
+    async def decrypt_ecies(self, message: "bytes",path: "str") -> "bytes":
         """
         Decrypts a message using ECIES at the given derivation path.
 
@@ -4423,6 +4635,8 @@ _UniffiConverterTypeSignerError,
 
         # Returns
         Decrypted data, or a `SignerError`
+
+        See also: [JavaScript `decryptEcies`](https://docs.spark.money/wallets/spark-signer#decrypt-ecies)
         """
 
         _UniffiConverterBytes.check_lower(message)
@@ -4430,7 +4644,7 @@ _UniffiConverterTypeSignerError,
         _UniffiConverterString.check_lower(path)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_ecies_decrypt(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_decrypt_ecies(
                 self._uniffi_clone_pointer(), 
         _UniffiConverterBytes.lower(message),
         _UniffiConverterString.lower(path)
@@ -4483,16 +4697,55 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def generate_frost_signing_commitments(self, ) -> "ExternalFrostCommitments":
+    async def hmac_sha256(self, message: "bytes",path: "str") -> "HashedMessageBytes":
+        """
+        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`
+
+        See also: [JavaScript `htlcHMAC`](https://docs.spark.money/wallets/spark-signer#generate-htlc-hmac)
+        """
+
+        _UniffiConverterBytes.check_lower(message)
+        
+        _UniffiConverterString.check_lower(path)
+        
+        return await _uniffi_rust_call_async(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_hmac_sha256(
+                self._uniffi_clone_pointer(), 
+        _UniffiConverterBytes.lower(message),
+        _UniffiConverterString.lower(path)
+            ),
+            _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
+            _UniffiLib.ffi_breez_sdk_spark_rust_future_free_rust_buffer,
+            # lift function
+            _UniffiConverterTypeHashedMessageBytes.lift,
+            
+    # Error FFI converter
+_UniffiConverterTypeSignerError,
+
+        )
+
+
+
+    async def generate_random_signing_commitment(self, ) -> "ExternalFrostCommitments":
         """
         Generates Frost signing commitments for multi-party signing.
 
         # Returns
         Frost commitments with nonces, or a `SignerError`
+
+        See also: [JavaScript `getRandomSigningCommitment`](https://docs.spark.money/wallets/spark-signer#get-random-signing-commitment)
         """
 
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_frost_signing_commitments(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_signing_commitment(
                 self._uniffi_clone_pointer(), 
             ),
             _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
@@ -4516,7 +4769,7 @@ _UniffiConverterTypeSignerError,
         * `id` - The tree node identifier
 
         # Returns
-        The public key for the node, or an error string
+        The public key for the node, or a `SignerError`
         """
 
         _UniffiConverterTypeExternalTreeNodeId.check_lower(id)
@@ -4539,23 +4792,36 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def generate_random_key(self, ) -> "ExternalPrivateKeySource":
+    async def generate_random_secret(self, ) -> "ExternalEncryptedSecret":
         """
-        Generates a random private key.
+        Generates a random secret that is encrypted and known only to the signer.
+
+        This method creates a new random secret and returns it in encrypted form.
+        The plaintext secret never leaves the signer boundary, providing a secure way
+        to create secrets that can be referenced in subsequent operations without
+        exposing them.
+
+        This is conceptually similar to Spark's key derivation system where secrets
+        are represented by opaque references (like tree node IDs or Random) rather than raw values.
+        The encrypted secret can be passed to other signer methods that need to operate
+        on it, while keeping the actual secret material protected within the signer.
 
         # Returns
-        A randomly generated private key source, or an error string
+        An encrypted secret that can be used in subsequent signer operations,
+        or a `SignerError` if generation fails.
+
+        See also: [Key Derivation System](https://docs.spark.money/wallets/spark-signer#the-keyderivation-system)
         """
 
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_key(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_generate_random_secret(
                 self._uniffi_clone_pointer(), 
             ),
             _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_free_rust_buffer,
             # lift function
-            _UniffiConverterTypeExternalPrivateKeySource.lift,
+            _UniffiConverterTypeExternalEncryptedSecret.lift,
             
     # Error FFI converter
 _UniffiConverterTypeSignerError,
@@ -4564,21 +4830,23 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def get_static_deposit_private_key_source(self, index: "int") -> "ExternalPrivateKeySource":
+    async def static_deposit_secret_encrypted(self, index: "int") -> "ExternalSecretSource":
         """
-        Gets a static deposit private key source by index.
+        Gets an encrypted static deposit secret by index.
 
         # Arguments
-        * `index` - The index of the static deposit key
+        * `index` - The index of the static deposit secret
 
         # Returns
-        The private key source, or an error string
+        The encrypted secret, or a `SignerError`
+
+        This is the encrypted version of: [JavaScript `getStaticDepositSecretKey`](https://docs.spark.money/wallets/spark-signer#get-static-deposit-secret-key)
         """
 
         _UniffiConverterUInt32.check_lower(index)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_private_key_source(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_secret_encrypted(
                 self._uniffi_clone_pointer(), 
         _UniffiConverterUInt32.lower(index)
             ),
@@ -4586,7 +4854,7 @@ _UniffiConverterTypeSignerError,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_free_rust_buffer,
             # lift function
-            _UniffiConverterTypeExternalPrivateKeySource.lift,
+            _UniffiConverterTypeExternalSecretSource.lift,
             
     # Error FFI converter
 _UniffiConverterTypeSignerError,
@@ -4595,21 +4863,23 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def get_static_deposit_private_key(self, index: "int") -> "PrivateKeyBytes":
+    async def static_deposit_secret(self, index: "int") -> "SecretBytes":
         """
-        Gets a static deposit private key by index.
+        Gets a static deposit secret by index.
 
         # Arguments
-        * `index` - The index of the static deposit key
+        * `index` - The index of the static deposit secret
 
         # Returns
-        The 32-byte private key, or an error string
+        The 32-byte secret, or a `SignerError`
+
+        See also: [JavaScript `getStaticDepositSecretKey`](https://docs.spark.money/wallets/spark-signer#get-static-deposit-secret-key)
         """
 
         _UniffiConverterUInt32.check_lower(index)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_private_key(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_secret(
                 self._uniffi_clone_pointer(), 
         _UniffiConverterUInt32.lower(index)
             ),
@@ -4617,7 +4887,7 @@ _UniffiConverterTypeSignerError,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_free_rust_buffer,
             # lift function
-            _UniffiConverterTypePrivateKeyBytes.lift,
+            _UniffiConverterTypeSecretBytes.lift,
             
     # Error FFI converter
 _UniffiConverterTypeSignerError,
@@ -4626,21 +4896,23 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def get_static_deposit_public_key(self, index: "int") -> "PublicKeyBytes":
+    async def static_deposit_signing_key(self, index: "int") -> "PublicKeyBytes":
         """
-        Gets a static deposit public key by index.
+        Gets a static deposit signing public key by index.
 
         # Arguments
-        * `index` - The index of the static deposit key
+        * `index` - The index of the static deposit public signing key
 
         # Returns
-        The 33-byte public key, or an error string
+        The 33-byte public key, or a `SignerError`
+
+        See also: [JavaScript `getStaticDepositSigningKey`](https://docs.spark.money/wallets/spark-signer#get-static-deposit-signing-key)
         """
 
         _UniffiConverterUInt32.check_lower(index)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_static_deposit_public_key(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_static_deposit_signing_key(
                 self._uniffi_clone_pointer(), 
         _UniffiConverterUInt32.lower(index)
             ),
@@ -4657,33 +4929,36 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def subtract_private_keys(self, signing_key: "ExternalPrivateKeySource",new_signing_key: "ExternalPrivateKeySource") -> "ExternalPrivateKeySource":
+    async def subtract_secrets(self, signing_key: "ExternalSecretSource",new_signing_key: "ExternalSecretSource") -> "ExternalSecretSource":
         """
-        Subtracts one private key from another.
+        Subtracts one secret from another.
 
         # Arguments
-        * `signing_key` - The first private key source
-        * `new_signing_key` - The second private key source to subtract
+        * `signing_key` - The first secret
+        * `new_signing_key` - The second secret to subtract
 
         # Returns
-        The resulting private key source, or an error string
+        The resulting secret, or a `SignerError`
+
+        See also: [JavaScript `subtractSplitAndEncrypt`](https://docs.spark.money/wallets/spark-signer#subtract,-split,-and-encrypt)
+        (this method provides the subtraction step of that higher-level operation)
         """
 
-        _UniffiConverterTypeExternalPrivateKeySource.check_lower(signing_key)
+        _UniffiConverterTypeExternalSecretSource.check_lower(signing_key)
         
-        _UniffiConverterTypeExternalPrivateKeySource.check_lower(new_signing_key)
+        _UniffiConverterTypeExternalSecretSource.check_lower(new_signing_key)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_subtract_private_keys(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_subtract_secrets(
                 self._uniffi_clone_pointer(), 
-        _UniffiConverterTypeExternalPrivateKeySource.lower(signing_key),
-        _UniffiConverterTypeExternalPrivateKeySource.lower(new_signing_key)
+        _UniffiConverterTypeExternalSecretSource.lower(signing_key),
+        _UniffiConverterTypeExternalSecretSource.lower(new_signing_key)
             ),
             _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_free_rust_buffer,
             # lift function
-            _UniffiConverterTypeExternalPrivateKeySource.lift,
+            _UniffiConverterTypeExternalSecretSource.lift,
             
     # Error FFI converter
 _UniffiConverterTypeSignerError,
@@ -4692,7 +4967,7 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def split_secret(self, secret: "ExternalSecretToSplit",threshold: "int",num_shares: "int") -> "typing.List[ExternalVerifiableSecretShare]":
+    async def split_secret_with_proofs(self, secret: "ExternalSecretToSplit",threshold: "int",num_shares: "int") -> "typing.List[ExternalVerifiableSecretShare]":
         """
         Splits a secret with proofs using Shamir's Secret Sharing.
 
@@ -4702,7 +4977,9 @@ _UniffiConverterTypeSignerError,
         * `num_shares` - Total number of shares to create
 
         # Returns
-        Vector of verifiable secret shares, or an error string
+        Vector of verifiable secret shares, or a `SignerError`
+
+        See also: [JavaScript `splitSecretWithProofs`](https://docs.spark.money/wallets/spark-signer#split-secret-with-proofs)
         """
 
         _UniffiConverterTypeExternalSecretToSplit.check_lower(secret)
@@ -4712,7 +4989,7 @@ _UniffiConverterTypeSignerError,
         _UniffiConverterUInt32.check_lower(num_shares)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_split_secret(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_split_secret_with_proofs(
                 self._uniffi_clone_pointer(), 
         _UniffiConverterTypeExternalSecretToSplit.lower(secret),
         _UniffiConverterUInt32.lower(threshold),
@@ -4731,26 +5008,26 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def encrypt_private_key_for_receiver(self, private_key: "ExternalEncryptedPrivateKey",receiver_public_key: "PublicKeyBytes") -> "bytes":
+    async def encrypt_secret_for_receiver(self, encrypted_secret: "ExternalEncryptedSecret",receiver_public_key: "PublicKeyBytes") -> "bytes":
         """
-        Encrypts a private key for a specific receiver's public key.
+        Encrypts a secret for a specific receiver's public key.
 
         # Arguments
-        * `private_key` - The encrypted private key to re-encrypt
+        * `encrypted_secret` - The encrypted secret to re-encrypt
         * `receiver_public_key` - The receiver's 33-byte public key
 
         # Returns
-        Encrypted data for the receiver, or an error string
+        Encrypted data for the receiver, or a `SignerError`
         """
 
-        _UniffiConverterTypeExternalEncryptedPrivateKey.check_lower(private_key)
+        _UniffiConverterTypeExternalEncryptedSecret.check_lower(encrypted_secret)
         
         _UniffiConverterTypePublicKeyBytes.check_lower(receiver_public_key)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_private_key_for_receiver(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_encrypt_secret_for_receiver(
                 self._uniffi_clone_pointer(), 
-        _UniffiConverterTypeExternalEncryptedPrivateKey.lower(private_key),
+        _UniffiConverterTypeExternalEncryptedSecret.lower(encrypted_secret),
         _UniffiConverterTypePublicKeyBytes.lower(receiver_public_key)
             ),
             _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
@@ -4766,23 +5043,25 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def get_public_key_from_private_key_source(self, private_key: "ExternalPrivateKeySource") -> "PublicKeyBytes":
+    async def public_key_from_secret(self, secret: "ExternalSecretSource") -> "PublicKeyBytes":
         """
-        Gets the public key from a private key source.
+        Gets the public key from a secret.
 
         # Arguments
-        * `private_key` - The private key source
+        * `secret` - The secret
 
         # Returns
-        The corresponding 33-byte public key, or an error string
+        The corresponding 33-byte public key, or a `SignerError`
+
+        See also: [JavaScript `getPublicKeyFromDerivation`](https://docs.spark.money/wallets/spark-signer#get-public-key-from-derivation)
         """
 
-        _UniffiConverterTypeExternalPrivateKeySource.check_lower(private_key)
+        _UniffiConverterTypeExternalSecretSource.check_lower(secret)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_get_public_key_from_private_key_source(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_public_key_from_secret(
                 self._uniffi_clone_pointer(), 
-        _UniffiConverterTypeExternalPrivateKeySource.lower(private_key)
+        _UniffiConverterTypeExternalSecretSource.lower(secret)
             ),
             _UniffiLib.ffi_breez_sdk_spark_rust_future_poll_rust_buffer,
             _UniffiLib.ffi_breez_sdk_spark_rust_future_complete_rust_buffer,
@@ -4805,7 +5084,9 @@ _UniffiConverterTypeSignerError,
         * `request` - The Frost signing request
 
         # Returns
-        A signature share, or an error string
+        A signature share, or a `SignerError`
+
+        See also: [JavaScript `signFrost`](https://docs.spark.money/wallets/spark-signer#frost-signing)
         """
 
         _UniffiConverterTypeExternalSignFrostRequest.check_lower(request)
@@ -4828,7 +5109,7 @@ _UniffiConverterTypeSignerError,
 
 
 
-    async def aggregate_frost_signatures(self, request: "ExternalAggregateFrostRequest") -> "ExternalFrostSignature":
+    async def aggregate_frost(self, request: "ExternalAggregateFrostRequest") -> "ExternalFrostSignature":
         """
         Aggregates Frost signature shares into a final signature.
 
@@ -4836,13 +5117,15 @@ _UniffiConverterTypeSignerError,
         * `request` - The Frost aggregation request
 
         # Returns
-        The aggregated Frost signature, or an error string
+        The aggregated Frost signature, or a `SignerError`
+
+        See also: [JavaScript `aggregateFrost`](https://docs.spark.money/wallets/spark-signer#aggregate-frost-signatures)
         """
 
         _UniffiConverterTypeExternalAggregateFrostRequest.check_lower(request)
         
         return await _uniffi_rust_call_async(
-            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_aggregate_frost_signatures(
+            _UniffiLib.uniffi_breez_sdk_spark_fn_method_externalsigner_aggregate_frost(
                 self._uniffi_clone_pointer(), 
         _UniffiConverterTypeExternalAggregateFrostRequest.lower(request)
             ),
@@ -4932,7 +5215,7 @@ class _UniffiTraitImplExternalSigner:
         ):
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterBytes.lift(message), _UniffiConverterString.lift(path), )
+            args = (_UniffiConverterTypeMessageBytes.lift(message), _UniffiConverterString.lift(path), )
             method = uniffi_obj.sign_ecdsa
             return method(*args)
 
@@ -4967,7 +5250,7 @@ class _UniffiTraitImplExternalSigner:
         ):
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterBytes.lift(message), _UniffiConverterString.lift(path), )
+            args = (_UniffiConverterTypeMessageBytes.lift(message), _UniffiConverterString.lift(path), )
             method = uniffi_obj.sign_ecdsa_recoverable
             return method(*args)
 
@@ -4992,7 +5275,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
     @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD4
-    def ecies_encrypt(
+    def encrypt_ecies(
             uniffi_handle,
             message,
             path,
@@ -5003,7 +5286,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = (_UniffiConverterBytes.lift(message), _UniffiConverterString.lift(path), )
-            method = uniffi_obj.ecies_encrypt
+            method = uniffi_obj.encrypt_ecies
             return method(*args)
 
         
@@ -5027,7 +5310,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
     @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD5
-    def ecies_decrypt(
+    def decrypt_ecies(
             uniffi_handle,
             message,
             path,
@@ -5038,7 +5321,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = (_UniffiConverterBytes.lift(message), _UniffiConverterString.lift(path), )
-            method = uniffi_obj.ecies_decrypt
+            method = uniffi_obj.decrypt_ecies
             return method(*args)
 
         
@@ -5097,7 +5380,42 @@ class _UniffiTraitImplExternalSigner:
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
     @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD7
-    def generate_frost_signing_commitments(
+    def hmac_sha256(
+            uniffi_handle,
+            message,
+            path,
+            uniffi_future_callback,
+            uniffi_callback_data,
+            uniffi_out_return,
+        ):
+        uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
+        def make_call():
+            args = (_UniffiConverterBytes.lift(message), _UniffiConverterString.lift(path), )
+            method = uniffi_obj.hmac_sha256
+            return method(*args)
+
+        
+        def handle_success(return_value):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiConverterTypeHashedMessageBytes.lower(return_value),
+                    _UniffiRustCallStatus.default()
+                )
+            )
+
+        def handle_error(status_code, rust_buffer):
+            uniffi_future_callback(
+                uniffi_callback_data,
+                _UniffiForeignFutureStructRustBuffer(
+                    _UniffiRustBuffer.default(),
+                    _UniffiRustCallStatus(status_code, rust_buffer),
+                )
+            )
+        uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
+
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD8
+    def generate_random_signing_commitment(
             uniffi_handle,
             uniffi_future_callback,
             uniffi_callback_data,
@@ -5106,7 +5424,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = ()
-            method = uniffi_obj.generate_frost_signing_commitments
+            method = uniffi_obj.generate_random_signing_commitment
             return method(*args)
 
         
@@ -5129,7 +5447,7 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD8
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD9
     def get_public_key_for_node(
             uniffi_handle,
             id,
@@ -5163,8 +5481,8 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD9
-    def generate_random_key(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD10
+    def generate_random_secret(
             uniffi_handle,
             uniffi_future_callback,
             uniffi_callback_data,
@@ -5173,7 +5491,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = ()
-            method = uniffi_obj.generate_random_key
+            method = uniffi_obj.generate_random_secret
             return method(*args)
 
         
@@ -5181,7 +5499,7 @@ class _UniffiTraitImplExternalSigner:
             uniffi_future_callback(
                 uniffi_callback_data,
                 _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypeExternalPrivateKeySource.lower(return_value),
+                    _UniffiConverterTypeExternalEncryptedSecret.lower(return_value),
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -5196,8 +5514,8 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD10
-    def get_static_deposit_private_key_source(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD11
+    def static_deposit_secret_encrypted(
             uniffi_handle,
             index,
             uniffi_future_callback,
@@ -5207,7 +5525,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = (_UniffiConverterUInt32.lift(index), )
-            method = uniffi_obj.get_static_deposit_private_key_source
+            method = uniffi_obj.static_deposit_secret_encrypted
             return method(*args)
 
         
@@ -5215,7 +5533,7 @@ class _UniffiTraitImplExternalSigner:
             uniffi_future_callback(
                 uniffi_callback_data,
                 _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypeExternalPrivateKeySource.lower(return_value),
+                    _UniffiConverterTypeExternalSecretSource.lower(return_value),
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -5230,8 +5548,8 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD11
-    def get_static_deposit_private_key(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD12
+    def static_deposit_secret(
             uniffi_handle,
             index,
             uniffi_future_callback,
@@ -5241,7 +5559,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = (_UniffiConverterUInt32.lift(index), )
-            method = uniffi_obj.get_static_deposit_private_key
+            method = uniffi_obj.static_deposit_secret
             return method(*args)
 
         
@@ -5249,7 +5567,7 @@ class _UniffiTraitImplExternalSigner:
             uniffi_future_callback(
                 uniffi_callback_data,
                 _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypePrivateKeyBytes.lower(return_value),
+                    _UniffiConverterTypeSecretBytes.lower(return_value),
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -5264,8 +5582,8 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD12
-    def get_static_deposit_public_key(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD13
+    def static_deposit_signing_key(
             uniffi_handle,
             index,
             uniffi_future_callback,
@@ -5275,7 +5593,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = (_UniffiConverterUInt32.lift(index), )
-            method = uniffi_obj.get_static_deposit_public_key
+            method = uniffi_obj.static_deposit_signing_key
             return method(*args)
 
         
@@ -5298,8 +5616,8 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD13
-    def subtract_private_keys(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD14
+    def subtract_secrets(
             uniffi_handle,
             signing_key,
             new_signing_key,
@@ -5309,8 +5627,8 @@ class _UniffiTraitImplExternalSigner:
         ):
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterTypeExternalPrivateKeySource.lift(signing_key), _UniffiConverterTypeExternalPrivateKeySource.lift(new_signing_key), )
-            method = uniffi_obj.subtract_private_keys
+            args = (_UniffiConverterTypeExternalSecretSource.lift(signing_key), _UniffiConverterTypeExternalSecretSource.lift(new_signing_key), )
+            method = uniffi_obj.subtract_secrets
             return method(*args)
 
         
@@ -5318,7 +5636,7 @@ class _UniffiTraitImplExternalSigner:
             uniffi_future_callback(
                 uniffi_callback_data,
                 _UniffiForeignFutureStructRustBuffer(
-                    _UniffiConverterTypeExternalPrivateKeySource.lower(return_value),
+                    _UniffiConverterTypeExternalSecretSource.lower(return_value),
                     _UniffiRustCallStatus.default()
                 )
             )
@@ -5333,8 +5651,8 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD14
-    def split_secret(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD15
+    def split_secret_with_proofs(
             uniffi_handle,
             secret,
             threshold,
@@ -5346,7 +5664,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = (_UniffiConverterTypeExternalSecretToSplit.lift(secret), _UniffiConverterUInt32.lift(threshold), _UniffiConverterUInt32.lift(num_shares), )
-            method = uniffi_obj.split_secret
+            method = uniffi_obj.split_secret_with_proofs
             return method(*args)
 
         
@@ -5369,10 +5687,10 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD15
-    def encrypt_private_key_for_receiver(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD16
+    def encrypt_secret_for_receiver(
             uniffi_handle,
-            private_key,
+            encrypted_secret,
             receiver_public_key,
             uniffi_future_callback,
             uniffi_callback_data,
@@ -5380,8 +5698,8 @@ class _UniffiTraitImplExternalSigner:
         ):
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterTypeExternalEncryptedPrivateKey.lift(private_key), _UniffiConverterTypePublicKeyBytes.lift(receiver_public_key), )
-            method = uniffi_obj.encrypt_private_key_for_receiver
+            args = (_UniffiConverterTypeExternalEncryptedSecret.lift(encrypted_secret), _UniffiConverterTypePublicKeyBytes.lift(receiver_public_key), )
+            method = uniffi_obj.encrypt_secret_for_receiver
             return method(*args)
 
         
@@ -5404,18 +5722,18 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD16
-    def get_public_key_from_private_key_source(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD17
+    def public_key_from_secret(
             uniffi_handle,
-            private_key,
+            secret,
             uniffi_future_callback,
             uniffi_callback_data,
             uniffi_out_return,
         ):
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
-            args = (_UniffiConverterTypeExternalPrivateKeySource.lift(private_key), )
-            method = uniffi_obj.get_public_key_from_private_key_source
+            args = (_UniffiConverterTypeExternalSecretSource.lift(secret), )
+            method = uniffi_obj.public_key_from_secret
             return method(*args)
 
         
@@ -5438,7 +5756,7 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD17
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD18
     def sign_frost(
             uniffi_handle,
             request,
@@ -5472,8 +5790,8 @@ class _UniffiTraitImplExternalSigner:
             )
         uniffi_out_return[0] = _uniffi_trait_interface_call_async_with_error(make_call, handle_success, handle_error, SignerError, _UniffiConverterTypeSignerError.lower)
 
-    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD18
-    def aggregate_frost_signatures(
+    @_UNIFFI_CALLBACK_INTERFACE_EXTERNAL_SIGNER_METHOD19
+    def aggregate_frost(
             uniffi_handle,
             request,
             uniffi_future_callback,
@@ -5483,7 +5801,7 @@ class _UniffiTraitImplExternalSigner:
         uniffi_obj = _UniffiConverterTypeExternalSigner._handle_map.get(uniffi_handle)
         def make_call():
             args = (_UniffiConverterTypeExternalAggregateFrostRequest.lift(request), )
-            method = uniffi_obj.aggregate_frost_signatures
+            method = uniffi_obj.aggregate_frost
             return method(*args)
 
         
@@ -5516,21 +5834,22 @@ class _UniffiTraitImplExternalSigner:
         derive_public_key,
         sign_ecdsa,
         sign_ecdsa_recoverable,
-        ecies_encrypt,
-        ecies_decrypt,
+        encrypt_ecies,
+        decrypt_ecies,
         sign_hash_schnorr,
-        generate_frost_signing_commitments,
+        hmac_sha256,
+        generate_random_signing_commitment,
         get_public_key_for_node,
-        generate_random_key,
-        get_static_deposit_private_key_source,
-        get_static_deposit_private_key,
-        get_static_deposit_public_key,
-        subtract_private_keys,
-        split_secret,
-        encrypt_private_key_for_receiver,
-        get_public_key_from_private_key_source,
+        generate_random_secret,
+        static_deposit_secret_encrypted,
+        static_deposit_secret,
+        static_deposit_signing_key,
+        subtract_secrets,
+        split_secret_with_proofs,
+        encrypt_secret_for_receiver,
+        public_key_from_secret,
         sign_frost,
-        aggregate_frost_signatures,
+        aggregate_frost,
         _uniffi_free
     )
     # Send Rust a pointer to the VTable.  Note: this means we need to keep the struct alive forever,
@@ -10119,60 +10438,272 @@ class _UniffiConverterTypeConnectWithSignerRequest(_UniffiConverterRustBuffer):
         _UniffiConverterString.write(value.storage_dir, buf)
 
 
-class CreateIssuerTokenRequest:
-    name: "str"
-    ticker: "str"
-    decimals: "int"
-    is_freezable: "bool"
-    max_supply: "U128"
-    def __init__(self, *, name: "str", ticker: "str", decimals: "int", is_freezable: "bool", max_supply: "U128"):
-        self.name = name
-        self.ticker = ticker
-        self.decimals = decimals
-        self.is_freezable = is_freezable
-        self.max_supply = max_supply
+class ConversionEstimate:
+    """
+    Response from estimating a conversion, used when preparing a payment that requires conversion
+    """
+
+    options: "ConversionOptions"
+    """
+    The conversion options used for the estimate
+    """
+
+    amount: "U128"
+    """
+    The estimated amount to be received from the conversion
+    Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
+    """
+
+    fee: "U128"
+    """
+    The fee estimated for the conversion
+    Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
+    """
+
+    def __init__(self, *, options: "ConversionOptions", amount: "U128", fee: "U128"):
+        self.options = options
+        self.amount = amount
+        self.fee = fee
 
     def __str__(self):
-        return "CreateIssuerTokenRequest(name={}, ticker={}, decimals={}, is_freezable={}, max_supply={})".format(self.name, self.ticker, self.decimals, self.is_freezable, self.max_supply)
+        return "ConversionEstimate(options={}, amount={}, fee={})".format(self.options, self.amount, self.fee)
 
     def __eq__(self, other):
-        if self.name != other.name:
-            return False
-        if self.ticker != other.ticker:
-            return False
-        if self.decimals != other.decimals:
+        if self.options != other.options:
             return False
-        if self.is_freezable != other.is_freezable:
+        if self.amount != other.amount:
             return False
-        if self.max_supply != other.max_supply:
+        if self.fee != other.fee:
             return False
         return True
 
-class _UniffiConverterTypeCreateIssuerTokenRequest(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeConversionEstimate(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return CreateIssuerTokenRequest(
-            name=_UniffiConverterString.read(buf),
-            ticker=_UniffiConverterString.read(buf),
-            decimals=_UniffiConverterUInt32.read(buf),
-            is_freezable=_UniffiConverterBool.read(buf),
-            max_supply=_UniffiConverterTypeU128.read(buf),
+        return ConversionEstimate(
+            options=_UniffiConverterTypeConversionOptions.read(buf),
+            amount=_UniffiConverterTypeU128.read(buf),
+            fee=_UniffiConverterTypeU128.read(buf),
         )
 
     @staticmethod
     def check_lower(value):
-        _UniffiConverterString.check_lower(value.name)
-        _UniffiConverterString.check_lower(value.ticker)
-        _UniffiConverterUInt32.check_lower(value.decimals)
-        _UniffiConverterBool.check_lower(value.is_freezable)
-        _UniffiConverterTypeU128.check_lower(value.max_supply)
+        _UniffiConverterTypeConversionOptions.check_lower(value.options)
+        _UniffiConverterTypeU128.check_lower(value.amount)
+        _UniffiConverterTypeU128.check_lower(value.fee)
 
     @staticmethod
     def write(value, buf):
-        _UniffiConverterString.write(value.name, buf)
-        _UniffiConverterString.write(value.ticker, buf)
-        _UniffiConverterUInt32.write(value.decimals, buf)
-        _UniffiConverterBool.write(value.is_freezable, buf)
+        _UniffiConverterTypeConversionOptions.write(value.options, buf)
+        _UniffiConverterTypeU128.write(value.amount, buf)
+        _UniffiConverterTypeU128.write(value.fee, buf)
+
+
+class ConversionInfo:
+    pool_id: "str"
+    """
+    The pool id associated with the conversion
+    """
+
+    conversion_id: "str"
+    """
+    The conversion id shared by both sides of the conversion
+    """
+
+    status: "ConversionStatus"
+    """
+    The status of the conversion
+    """
+
+    fee: "typing.Optional[U128]"
+    """
+    The fee paid for the conversion
+    Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
+    """
+
+    purpose: "typing.Optional[ConversionPurpose]"
+    """
+    The purpose of the conversion
+    """
+
+    def __init__(self, *, pool_id: "str", conversion_id: "str", status: "ConversionStatus", fee: "typing.Optional[U128]", purpose: "typing.Optional[ConversionPurpose]"):
+        self.pool_id = pool_id
+        self.conversion_id = conversion_id
+        self.status = status
+        self.fee = fee
+        self.purpose = purpose
+
+    def __str__(self):
+        return "ConversionInfo(pool_id={}, conversion_id={}, status={}, fee={}, purpose={})".format(self.pool_id, self.conversion_id, self.status, self.fee, self.purpose)
+
+    def __eq__(self, other):
+        if self.pool_id != other.pool_id:
+            return False
+        if self.conversion_id != other.conversion_id:
+            return False
+        if self.status != other.status:
+            return False
+        if self.fee != other.fee:
+            return False
+        if self.purpose != other.purpose:
+            return False
+        return True
+
+class _UniffiConverterTypeConversionInfo(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return ConversionInfo(
+            pool_id=_UniffiConverterString.read(buf),
+            conversion_id=_UniffiConverterString.read(buf),
+            status=_UniffiConverterTypeConversionStatus.read(buf),
+            fee=_UniffiConverterOptionalTypeU128.read(buf),
+            purpose=_UniffiConverterOptionalTypeConversionPurpose.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterString.check_lower(value.pool_id)
+        _UniffiConverterString.check_lower(value.conversion_id)
+        _UniffiConverterTypeConversionStatus.check_lower(value.status)
+        _UniffiConverterOptionalTypeU128.check_lower(value.fee)
+        _UniffiConverterOptionalTypeConversionPurpose.check_lower(value.purpose)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterString.write(value.pool_id, buf)
+        _UniffiConverterString.write(value.conversion_id, buf)
+        _UniffiConverterTypeConversionStatus.write(value.status, buf)
+        _UniffiConverterOptionalTypeU128.write(value.fee, buf)
+        _UniffiConverterOptionalTypeConversionPurpose.write(value.purpose, buf)
+
+
+class ConversionOptions:
+    """
+    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.
+    """
+
+    conversion_type: "ConversionType"
+    """
+    The type of conversion to perform when fulfilling the payment
+    """
+
+    max_slippage_bps: "typing.Optional[int]"
+    """
+    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)`.
+    """
+
+    completion_timeout_secs: "typing.Optional[int]"
+    """
+    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.
+    """
+
+    def __init__(self, *, conversion_type: "ConversionType", max_slippage_bps: "typing.Optional[int]" = _DEFAULT, completion_timeout_secs: "typing.Optional[int]" = _DEFAULT):
+        self.conversion_type = conversion_type
+        if max_slippage_bps is _DEFAULT:
+            self.max_slippage_bps = None
+        else:
+            self.max_slippage_bps = max_slippage_bps
+        if completion_timeout_secs is _DEFAULT:
+            self.completion_timeout_secs = None
+        else:
+            self.completion_timeout_secs = completion_timeout_secs
+
+    def __str__(self):
+        return "ConversionOptions(conversion_type={}, max_slippage_bps={}, completion_timeout_secs={})".format(self.conversion_type, self.max_slippage_bps, self.completion_timeout_secs)
+
+    def __eq__(self, other):
+        if self.conversion_type != other.conversion_type:
+            return False
+        if self.max_slippage_bps != other.max_slippage_bps:
+            return False
+        if self.completion_timeout_secs != other.completion_timeout_secs:
+            return False
+        return True
+
+class _UniffiConverterTypeConversionOptions(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return ConversionOptions(
+            conversion_type=_UniffiConverterTypeConversionType.read(buf),
+            max_slippage_bps=_UniffiConverterOptionalUInt32.read(buf),
+            completion_timeout_secs=_UniffiConverterOptionalUInt32.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterTypeConversionType.check_lower(value.conversion_type)
+        _UniffiConverterOptionalUInt32.check_lower(value.max_slippage_bps)
+        _UniffiConverterOptionalUInt32.check_lower(value.completion_timeout_secs)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterTypeConversionType.write(value.conversion_type, buf)
+        _UniffiConverterOptionalUInt32.write(value.max_slippage_bps, buf)
+        _UniffiConverterOptionalUInt32.write(value.completion_timeout_secs, buf)
+
+
+class CreateIssuerTokenRequest:
+    name: "str"
+    ticker: "str"
+    decimals: "int"
+    is_freezable: "bool"
+    max_supply: "U128"
+    def __init__(self, *, name: "str", ticker: "str", decimals: "int", is_freezable: "bool", max_supply: "U128"):
+        self.name = name
+        self.ticker = ticker
+        self.decimals = decimals
+        self.is_freezable = is_freezable
+        self.max_supply = max_supply
+
+    def __str__(self):
+        return "CreateIssuerTokenRequest(name={}, ticker={}, decimals={}, is_freezable={}, max_supply={})".format(self.name, self.ticker, self.decimals, self.is_freezable, self.max_supply)
+
+    def __eq__(self, other):
+        if self.name != other.name:
+            return False
+        if self.ticker != other.ticker:
+            return False
+        if self.decimals != other.decimals:
+            return False
+        if self.is_freezable != other.is_freezable:
+            return False
+        if self.max_supply != other.max_supply:
+            return False
+        return True
+
+class _UniffiConverterTypeCreateIssuerTokenRequest(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return CreateIssuerTokenRequest(
+            name=_UniffiConverterString.read(buf),
+            ticker=_UniffiConverterString.read(buf),
+            decimals=_UniffiConverterUInt32.read(buf),
+            is_freezable=_UniffiConverterBool.read(buf),
+            max_supply=_UniffiConverterTypeU128.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterString.check_lower(value.name)
+        _UniffiConverterString.check_lower(value.ticker)
+        _UniffiConverterUInt32.check_lower(value.decimals)
+        _UniffiConverterBool.check_lower(value.is_freezable)
+        _UniffiConverterTypeU128.check_lower(value.max_supply)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterString.write(value.name, buf)
+        _UniffiConverterString.write(value.ticker, buf)
+        _UniffiConverterUInt32.write(value.decimals, buf)
+        _UniffiConverterBool.write(value.is_freezable, buf)
         _UniffiConverterTypeU128.write(value.max_supply, buf)
 
 
@@ -10509,9 +11040,9 @@ class _UniffiConverterTypeExternalAggregateFrostRequest(_UniffiConverterRustBuff
         _UniffiConverterOptionalBytes.write(value.adaptor_public_key, buf)
 
 
-class ExternalEncryptedPrivateKey:
+class ExternalEncryptedSecret:
     """
-    FFI-safe representation of `spark_wallet::EncryptedPrivateKey`
+    FFI-safe representation of `spark_wallet::EncryptedSecret`
     """
 
     ciphertext: "bytes"
@@ -10523,17 +11054,17 @@ class ExternalEncryptedPrivateKey:
         self.ciphertext = ciphertext
 
     def __str__(self):
-        return "ExternalEncryptedPrivateKey(ciphertext={})".format(self.ciphertext)
+        return "ExternalEncryptedSecret(ciphertext={})".format(self.ciphertext)
 
     def __eq__(self, other):
         if self.ciphertext != other.ciphertext:
             return False
         return True
 
-class _UniffiConverterTypeExternalEncryptedPrivateKey(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeExternalEncryptedSecret(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return ExternalEncryptedPrivateKey(
+        return ExternalEncryptedSecret(
             ciphertext=_UniffiConverterBytes.read(buf),
         )
 
@@ -10887,7 +11418,7 @@ class ExternalSignFrostRequest:
     The public key (33 bytes compressed)
     """
 
-    private_key: "ExternalPrivateKeySource"
+    secret: "ExternalSecretSource"
     """
     The private key source
     """
@@ -10912,24 +11443,24 @@ class ExternalSignFrostRequest:
     Optional adaptor public key (33 bytes compressed)
     """
 
-    def __init__(self, *, message: "bytes", public_key: "bytes", private_key: "ExternalPrivateKeySource", verifying_key: "bytes", self_nonce_commitment: "ExternalFrostCommitments", statechain_commitments: "typing.List[IdentifierCommitmentPair]", adaptor_public_key: "typing.Optional[bytes]"):
+    def __init__(self, *, message: "bytes", public_key: "bytes", secret: "ExternalSecretSource", verifying_key: "bytes", self_nonce_commitment: "ExternalFrostCommitments", statechain_commitments: "typing.List[IdentifierCommitmentPair]", adaptor_public_key: "typing.Optional[bytes]"):
         self.message = message
         self.public_key = public_key
-        self.private_key = private_key
+        self.secret = secret
         self.verifying_key = verifying_key
         self.self_nonce_commitment = self_nonce_commitment
         self.statechain_commitments = statechain_commitments
         self.adaptor_public_key = adaptor_public_key
 
     def __str__(self):
-        return "ExternalSignFrostRequest(message={}, public_key={}, private_key={}, verifying_key={}, self_nonce_commitment={}, statechain_commitments={}, adaptor_public_key={})".format(self.message, self.public_key, self.private_key, self.verifying_key, self.self_nonce_commitment, self.statechain_commitments, self.adaptor_public_key)
+        return "ExternalSignFrostRequest(message={}, public_key={}, secret={}, verifying_key={}, self_nonce_commitment={}, statechain_commitments={}, adaptor_public_key={})".format(self.message, self.public_key, self.secret, self.verifying_key, self.self_nonce_commitment, self.statechain_commitments, self.adaptor_public_key)
 
     def __eq__(self, other):
         if self.message != other.message:
             return False
         if self.public_key != other.public_key:
             return False
-        if self.private_key != other.private_key:
+        if self.secret != other.secret:
             return False
         if self.verifying_key != other.verifying_key:
             return False
@@ -10947,7 +11478,7 @@ class _UniffiConverterTypeExternalSignFrostRequest(_UniffiConverterRustBuffer):
         return ExternalSignFrostRequest(
             message=_UniffiConverterBytes.read(buf),
             public_key=_UniffiConverterBytes.read(buf),
-            private_key=_UniffiConverterTypeExternalPrivateKeySource.read(buf),
+            secret=_UniffiConverterTypeExternalSecretSource.read(buf),
             verifying_key=_UniffiConverterBytes.read(buf),
             self_nonce_commitment=_UniffiConverterTypeExternalFrostCommitments.read(buf),
             statechain_commitments=_UniffiConverterSequenceTypeIdentifierCommitmentPair.read(buf),
@@ -10958,7 +11489,7 @@ class _UniffiConverterTypeExternalSignFrostRequest(_UniffiConverterRustBuffer):
     def check_lower(value):
         _UniffiConverterBytes.check_lower(value.message)
         _UniffiConverterBytes.check_lower(value.public_key)
-        _UniffiConverterTypeExternalPrivateKeySource.check_lower(value.private_key)
+        _UniffiConverterTypeExternalSecretSource.check_lower(value.secret)
         _UniffiConverterBytes.check_lower(value.verifying_key)
         _UniffiConverterTypeExternalFrostCommitments.check_lower(value.self_nonce_commitment)
         _UniffiConverterSequenceTypeIdentifierCommitmentPair.check_lower(value.statechain_commitments)
@@ -10968,7 +11499,7 @@ class _UniffiConverterTypeExternalSignFrostRequest(_UniffiConverterRustBuffer):
     def write(value, buf):
         _UniffiConverterBytes.write(value.message, buf)
         _UniffiConverterBytes.write(value.public_key, buf)
-        _UniffiConverterTypeExternalPrivateKeySource.write(value.private_key, buf)
+        _UniffiConverterTypeExternalSecretSource.write(value.secret, buf)
         _UniffiConverterBytes.write(value.verifying_key, buf)
         _UniffiConverterTypeExternalFrostCommitments.write(value.self_nonce_commitment, buf)
         _UniffiConverterSequenceTypeIdentifierCommitmentPair.write(value.statechain_commitments, buf)
@@ -11108,8 +11639,8 @@ class _UniffiConverterTypeExternalVerifiableSecretShare(_UniffiConverterRustBuff
         _UniffiConverterSequenceBytes.write(value.proofs, buf)
 
 
-class FetchTokenConversionLimitsRequest:
-    conversion_type: "TokenConversionType"
+class FetchConversionLimitsRequest:
+    conversion_type: "ConversionType"
     """
     The type of conversion, either from or to Bitcoin.
     """
@@ -11119,7 +11650,7 @@ class FetchTokenConversionLimitsRequest:
     The token identifier when converting to a token.
     """
 
-    def __init__(self, *, conversion_type: "TokenConversionType", token_identifier: "typing.Optional[str]" = _DEFAULT):
+    def __init__(self, *, conversion_type: "ConversionType", token_identifier: "typing.Optional[str]" = _DEFAULT):
         self.conversion_type = conversion_type
         if token_identifier is _DEFAULT:
             self.token_identifier = None
@@ -11127,7 +11658,7 @@ class FetchTokenConversionLimitsRequest:
             self.token_identifier = token_identifier
 
     def __str__(self):
-        return "FetchTokenConversionLimitsRequest(conversion_type={}, token_identifier={})".format(self.conversion_type, self.token_identifier)
+        return "FetchConversionLimitsRequest(conversion_type={}, token_identifier={})".format(self.conversion_type, self.token_identifier)
 
     def __eq__(self, other):
         if self.conversion_type != other.conversion_type:
@@ -11136,26 +11667,26 @@ class FetchTokenConversionLimitsRequest:
             return False
         return True
 
-class _UniffiConverterTypeFetchTokenConversionLimitsRequest(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeFetchConversionLimitsRequest(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return FetchTokenConversionLimitsRequest(
-            conversion_type=_UniffiConverterTypeTokenConversionType.read(buf),
+        return FetchConversionLimitsRequest(
+            conversion_type=_UniffiConverterTypeConversionType.read(buf),
             token_identifier=_UniffiConverterOptionalString.read(buf),
         )
 
     @staticmethod
     def check_lower(value):
-        _UniffiConverterTypeTokenConversionType.check_lower(value.conversion_type)
+        _UniffiConverterTypeConversionType.check_lower(value.conversion_type)
         _UniffiConverterOptionalString.check_lower(value.token_identifier)
 
     @staticmethod
     def write(value, buf):
-        _UniffiConverterTypeTokenConversionType.write(value.conversion_type, buf)
+        _UniffiConverterTypeConversionType.write(value.conversion_type, buf)
         _UniffiConverterOptionalString.write(value.token_identifier, buf)
 
 
-class FetchTokenConversionLimitsResponse:
+class FetchConversionLimitsResponse:
     min_from_amount: "typing.Optional[U128]"
     """
     The minimum amount to be converted.
@@ -11173,7 +11704,7 @@ class FetchTokenConversionLimitsResponse:
         self.min_to_amount = min_to_amount
 
     def __str__(self):
-        return "FetchTokenConversionLimitsResponse(min_from_amount={}, min_to_amount={})".format(self.min_from_amount, self.min_to_amount)
+        return "FetchConversionLimitsResponse(min_from_amount={}, min_to_amount={})".format(self.min_from_amount, self.min_to_amount)
 
     def __eq__(self, other):
         if self.min_from_amount != other.min_from_amount:
@@ -11182,10 +11713,10 @@ class FetchTokenConversionLimitsResponse:
             return False
         return True
 
-class _UniffiConverterTypeFetchTokenConversionLimitsResponse(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeFetchConversionLimitsResponse(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
-        return FetchTokenConversionLimitsResponse(
+        return FetchConversionLimitsResponse(
             min_from_amount=_UniffiConverterOptionalTypeU128.read(buf),
             min_to_amount=_UniffiConverterOptionalTypeU128.read(buf),
         )
@@ -11503,6 +12034,35 @@ class _UniffiConverterTypeGetTokensMetadataResponse(_UniffiConverterRustBuffer):
         _UniffiConverterSequenceTypeTokenMetadata.write(value.tokens_metadata, buf)
 
 
+class HashedMessageBytes:
+    bytes: "bytes"
+    def __init__(self, *, bytes: "bytes"):
+        self.bytes = bytes
+
+    def __str__(self):
+        return "HashedMessageBytes(bytes={})".format(self.bytes)
+
+    def __eq__(self, other):
+        if self.bytes != other.bytes:
+            return False
+        return True
+
+class _UniffiConverterTypeHashedMessageBytes(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return HashedMessageBytes(
+            bytes=_UniffiConverterBytes.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterBytes.check_lower(value.bytes)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterBytes.write(value.bytes, buf)
+
+
 class IdentifierCommitmentPair:
     """
     FFI-safe wrapper for (Identifier, `SigningCommitments`) pair
@@ -12181,6 +12741,39 @@ class _UniffiConverterTypeLnurlAuthRequestDetails(_UniffiConverterRustBuffer):
         _UniffiConverterString.write(value.url, buf)
 
 
+class LnurlErrorDetails:
+    """
+    LNURL error details
+    """
+
+    reason: "str"
+    def __init__(self, *, reason: "str"):
+        self.reason = reason
+
+    def __str__(self):
+        return "LnurlErrorDetails(reason={})".format(self.reason)
+
+    def __eq__(self, other):
+        if self.reason != other.reason:
+            return False
+        return True
+
+class _UniffiConverterTypeLnurlErrorDetails(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return LnurlErrorDetails(
+            reason=_UniffiConverterString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterString.check_lower(value.reason)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterString.write(value.reason, buf)
+
+
 class LnurlPayInfo:
     """
     Represents the payment LNURL info
@@ -12827,6 +13420,39 @@ class _UniffiConverterTypeLogEntry(_UniffiConverterRustBuffer):
         _UniffiConverterString.write(value.level, buf)
 
 
+class MessageBytes:
+    """
+    FFI-safe representation of a 32-byte message digest for ECDSA signing
+    """
+
+    bytes: "bytes"
+    def __init__(self, *, bytes: "bytes"):
+        self.bytes = bytes
+
+    def __str__(self):
+        return "MessageBytes(bytes={})".format(self.bytes)
+
+    def __eq__(self, other):
+        if self.bytes != other.bytes:
+            return False
+        return True
+
+class _UniffiConverterTypeMessageBytes(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return MessageBytes(
+            bytes=_UniffiConverterBytes.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterBytes.check_lower(value.bytes)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterBytes.write(value.bytes, buf)
+
+
 class MessageSuccessActionData:
     message: "str"
     def __init__(self, *, message: "str"):
@@ -13143,16 +13769,16 @@ class PaymentMetadata:
     lnurl_pay_info: "typing.Optional[LnurlPayInfo]"
     lnurl_withdraw_info: "typing.Optional[LnurlWithdrawInfo]"
     lnurl_description: "typing.Optional[str]"
-    token_conversion_info: "typing.Optional[TokenConversionInfo]"
-    def __init__(self, *, parent_payment_id: "typing.Optional[str]", lnurl_pay_info: "typing.Optional[LnurlPayInfo]", lnurl_withdraw_info: "typing.Optional[LnurlWithdrawInfo]", lnurl_description: "typing.Optional[str]", token_conversion_info: "typing.Optional[TokenConversionInfo]"):
+    conversion_info: "typing.Optional[ConversionInfo]"
+    def __init__(self, *, parent_payment_id: "typing.Optional[str]", lnurl_pay_info: "typing.Optional[LnurlPayInfo]", lnurl_withdraw_info: "typing.Optional[LnurlWithdrawInfo]", lnurl_description: "typing.Optional[str]", conversion_info: "typing.Optional[ConversionInfo]"):
         self.parent_payment_id = parent_payment_id
         self.lnurl_pay_info = lnurl_pay_info
         self.lnurl_withdraw_info = lnurl_withdraw_info
         self.lnurl_description = lnurl_description
-        self.token_conversion_info = token_conversion_info
+        self.conversion_info = conversion_info
 
     def __str__(self):
-        return "PaymentMetadata(parent_payment_id={}, lnurl_pay_info={}, lnurl_withdraw_info={}, lnurl_description={}, token_conversion_info={})".format(self.parent_payment_id, self.lnurl_pay_info, self.lnurl_withdraw_info, self.lnurl_description, self.token_conversion_info)
+        return "PaymentMetadata(parent_payment_id={}, lnurl_pay_info={}, lnurl_withdraw_info={}, lnurl_description={}, conversion_info={})".format(self.parent_payment_id, self.lnurl_pay_info, self.lnurl_withdraw_info, self.lnurl_description, self.conversion_info)
 
     def __eq__(self, other):
         if self.parent_payment_id != other.parent_payment_id:
@@ -13163,7 +13789,7 @@ class PaymentMetadata:
             return False
         if self.lnurl_description != other.lnurl_description:
             return False
-        if self.token_conversion_info != other.token_conversion_info:
+        if self.conversion_info != other.conversion_info:
             return False
         return True
 
@@ -13175,7 +13801,7 @@ class _UniffiConverterTypePaymentMetadata(_UniffiConverterRustBuffer):
             lnurl_pay_info=_UniffiConverterOptionalTypeLnurlPayInfo.read(buf),
             lnurl_withdraw_info=_UniffiConverterOptionalTypeLnurlWithdrawInfo.read(buf),
             lnurl_description=_UniffiConverterOptionalString.read(buf),
-            token_conversion_info=_UniffiConverterOptionalTypeTokenConversionInfo.read(buf),
+            conversion_info=_UniffiConverterOptionalTypeConversionInfo.read(buf),
         )
 
     @staticmethod
@@ -13184,7 +13810,7 @@ class _UniffiConverterTypePaymentMetadata(_UniffiConverterRustBuffer):
         _UniffiConverterOptionalTypeLnurlPayInfo.check_lower(value.lnurl_pay_info)
         _UniffiConverterOptionalTypeLnurlWithdrawInfo.check_lower(value.lnurl_withdraw_info)
         _UniffiConverterOptionalString.check_lower(value.lnurl_description)
-        _UniffiConverterOptionalTypeTokenConversionInfo.check_lower(value.token_conversion_info)
+        _UniffiConverterOptionalTypeConversionInfo.check_lower(value.conversion_info)
 
     @staticmethod
     def write(value, buf):
@@ -13192,7 +13818,7 @@ class _UniffiConverterTypePaymentMetadata(_UniffiConverterRustBuffer):
         _UniffiConverterOptionalTypeLnurlPayInfo.write(value.lnurl_pay_info, buf)
         _UniffiConverterOptionalTypeLnurlWithdrawInfo.write(value.lnurl_withdraw_info, buf)
         _UniffiConverterOptionalString.write(value.lnurl_description, buf)
-        _UniffiConverterOptionalTypeTokenConversionInfo.write(value.token_conversion_info, buf)
+        _UniffiConverterOptionalTypeConversionInfo.write(value.conversion_info, buf)
 
 
 class PaymentRequestSource:
@@ -13365,12 +13991,12 @@ class PrepareSendPaymentRequest:
     May only be provided if the payment request is a spark address.
     """
 
-    token_conversion_options: "typing.Optional[TokenConversionOptions]"
+    conversion_options: "typing.Optional[ConversionOptions]"
     """
-    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
     """
 
-    def __init__(self, *, payment_request: "str", amount: "typing.Optional[U128]" = _DEFAULT, token_identifier: "typing.Optional[str]" = _DEFAULT, token_conversion_options: "typing.Optional[TokenConversionOptions]" = _DEFAULT):
+    def __init__(self, *, payment_request: "str", amount: "typing.Optional[U128]" = _DEFAULT, token_identifier: "typing.Optional[str]" = _DEFAULT, conversion_options: "typing.Optional[ConversionOptions]" = _DEFAULT):
         self.payment_request = payment_request
         if amount is _DEFAULT:
             self.amount = None
@@ -13380,13 +14006,13 @@ class PrepareSendPaymentRequest:
             self.token_identifier = None
         else:
             self.token_identifier = token_identifier
-        if token_conversion_options is _DEFAULT:
-            self.token_conversion_options = None
+        if conversion_options is _DEFAULT:
+            self.conversion_options = None
         else:
-            self.token_conversion_options = token_conversion_options
+            self.conversion_options = conversion_options
 
     def __str__(self):
-        return "PrepareSendPaymentRequest(payment_request={}, amount={}, token_identifier={}, token_conversion_options={})".format(self.payment_request, self.amount, self.token_identifier, self.token_conversion_options)
+        return "PrepareSendPaymentRequest(payment_request={}, amount={}, token_identifier={}, conversion_options={})".format(self.payment_request, self.amount, self.token_identifier, self.conversion_options)
 
     def __eq__(self, other):
         if self.payment_request != other.payment_request:
@@ -13395,7 +14021,7 @@ class PrepareSendPaymentRequest:
             return False
         if self.token_identifier != other.token_identifier:
             return False
-        if self.token_conversion_options != other.token_conversion_options:
+        if self.conversion_options != other.conversion_options:
             return False
         return True
 
@@ -13406,7 +14032,7 @@ class _UniffiConverterTypePrepareSendPaymentRequest(_UniffiConverterRustBuffer):
             payment_request=_UniffiConverterString.read(buf),
             amount=_UniffiConverterOptionalTypeU128.read(buf),
             token_identifier=_UniffiConverterOptionalString.read(buf),
-            token_conversion_options=_UniffiConverterOptionalTypeTokenConversionOptions.read(buf),
+            conversion_options=_UniffiConverterOptionalTypeConversionOptions.read(buf),
         )
 
     @staticmethod
@@ -13414,14 +14040,14 @@ class _UniffiConverterTypePrepareSendPaymentRequest(_UniffiConverterRustBuffer):
         _UniffiConverterString.check_lower(value.payment_request)
         _UniffiConverterOptionalTypeU128.check_lower(value.amount)
         _UniffiConverterOptionalString.check_lower(value.token_identifier)
-        _UniffiConverterOptionalTypeTokenConversionOptions.check_lower(value.token_conversion_options)
+        _UniffiConverterOptionalTypeConversionOptions.check_lower(value.conversion_options)
 
     @staticmethod
     def write(value, buf):
         _UniffiConverterString.write(value.payment_request, buf)
         _UniffiConverterOptionalTypeU128.write(value.amount, buf)
         _UniffiConverterOptionalString.write(value.token_identifier, buf)
-        _UniffiConverterOptionalTypeTokenConversionOptions.write(value.token_conversion_options, buf)
+        _UniffiConverterOptionalTypeConversionOptions.write(value.conversion_options, buf)
 
 
 class PrepareSendPaymentResponse:
@@ -13438,25 +14064,19 @@ class PrepareSendPaymentResponse:
     If empty, it is a Bitcoin payment.
     """
 
-    token_conversion_options: "typing.Optional[TokenConversionOptions]"
-    """
-    When set, the payment will include a token conversion step before sending the payment
-    """
-
-    token_conversion_fee: "typing.Optional[U128]"
+    conversion_estimate: "typing.Optional[ConversionEstimate]"
     """
-    The estimated token conversion fee if the payment involves a token conversion
+    When set, the payment will include a conversion step before sending the payment
     """
 
-    def __init__(self, *, payment_method: "SendPaymentMethod", amount: "U128", token_identifier: "typing.Optional[str]", token_conversion_options: "typing.Optional[TokenConversionOptions]", token_conversion_fee: "typing.Optional[U128]"):
+    def __init__(self, *, payment_method: "SendPaymentMethod", amount: "U128", token_identifier: "typing.Optional[str]", conversion_estimate: "typing.Optional[ConversionEstimate]"):
         self.payment_method = payment_method
         self.amount = amount
         self.token_identifier = token_identifier
-        self.token_conversion_options = token_conversion_options
-        self.token_conversion_fee = token_conversion_fee
+        self.conversion_estimate = conversion_estimate
 
     def __str__(self):
-        return "PrepareSendPaymentResponse(payment_method={}, amount={}, token_identifier={}, token_conversion_options={}, token_conversion_fee={})".format(self.payment_method, self.amount, self.token_identifier, self.token_conversion_options, self.token_conversion_fee)
+        return "PrepareSendPaymentResponse(payment_method={}, amount={}, token_identifier={}, conversion_estimate={})".format(self.payment_method, self.amount, self.token_identifier, self.conversion_estimate)
 
     def __eq__(self, other):
         if self.payment_method != other.payment_method:
@@ -13465,9 +14085,7 @@ class PrepareSendPaymentResponse:
             return False
         if self.token_identifier != other.token_identifier:
             return False
-        if self.token_conversion_options != other.token_conversion_options:
-            return False
-        if self.token_conversion_fee != other.token_conversion_fee:
+        if self.conversion_estimate != other.conversion_estimate:
             return False
         return True
 
@@ -13478,8 +14096,7 @@ class _UniffiConverterTypePrepareSendPaymentResponse(_UniffiConverterRustBuffer)
             payment_method=_UniffiConverterTypeSendPaymentMethod.read(buf),
             amount=_UniffiConverterTypeU128.read(buf),
             token_identifier=_UniffiConverterOptionalString.read(buf),
-            token_conversion_options=_UniffiConverterOptionalTypeTokenConversionOptions.read(buf),
-            token_conversion_fee=_UniffiConverterOptionalTypeU128.read(buf),
+            conversion_estimate=_UniffiConverterOptionalTypeConversionEstimate.read(buf),
         )
 
     @staticmethod
@@ -13487,55 +14104,20 @@ class _UniffiConverterTypePrepareSendPaymentResponse(_UniffiConverterRustBuffer)
         _UniffiConverterTypeSendPaymentMethod.check_lower(value.payment_method)
         _UniffiConverterTypeU128.check_lower(value.amount)
         _UniffiConverterOptionalString.check_lower(value.token_identifier)
-        _UniffiConverterOptionalTypeTokenConversionOptions.check_lower(value.token_conversion_options)
-        _UniffiConverterOptionalTypeU128.check_lower(value.token_conversion_fee)
+        _UniffiConverterOptionalTypeConversionEstimate.check_lower(value.conversion_estimate)
 
     @staticmethod
     def write(value, buf):
         _UniffiConverterTypeSendPaymentMethod.write(value.payment_method, buf)
         _UniffiConverterTypeU128.write(value.amount, buf)
         _UniffiConverterOptionalString.write(value.token_identifier, buf)
-        _UniffiConverterOptionalTypeTokenConversionOptions.write(value.token_conversion_options, buf)
-        _UniffiConverterOptionalTypeU128.write(value.token_conversion_fee, buf)
+        _UniffiConverterOptionalTypeConversionEstimate.write(value.conversion_estimate, buf)
 
 
-class PrivateKeyBytes:
+class ProvisionalPayment:
+    payment_id: "str"
     """
-    FFI-safe representation of a private key (32 bytes)
-    """
-
-    bytes: "bytes"
-    def __init__(self, *, bytes: "bytes"):
-        self.bytes = bytes
-
-    def __str__(self):
-        return "PrivateKeyBytes(bytes={})".format(self.bytes)
-
-    def __eq__(self, other):
-        if self.bytes != other.bytes:
-            return False
-        return True
-
-class _UniffiConverterTypePrivateKeyBytes(_UniffiConverterRustBuffer):
-    @staticmethod
-    def read(buf):
-        return PrivateKeyBytes(
-            bytes=_UniffiConverterBytes.read(buf),
-        )
-
-    @staticmethod
-    def check_lower(value):
-        _UniffiConverterBytes.check_lower(value.bytes)
-
-    @staticmethod
-    def write(value, buf):
-        _UniffiConverterBytes.write(value.bytes, buf)
-
-
-class ProvisionalPayment:
-    payment_id: "str"
-    """
-    Unique identifier for the payment
+    Unique identifier for the payment
     """
 
     amount: "U128"
@@ -14150,6 +14732,39 @@ class _UniffiConverterTypeSchnorrSignatureBytes(_UniffiConverterRustBuffer):
         _UniffiConverterBytes.write(value.bytes, buf)
 
 
+class SecretBytes:
+    """
+    FFI-safe representation of a private key (32 bytes)
+    """
+
+    bytes: "bytes"
+    def __init__(self, *, bytes: "bytes"):
+        self.bytes = bytes
+
+    def __str__(self):
+        return "SecretBytes(bytes={})".format(self.bytes)
+
+    def __eq__(self, other):
+        if self.bytes != other.bytes:
+            return False
+        return True
+
+class _UniffiConverterTypeSecretBytes(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return SecretBytes(
+            bytes=_UniffiConverterBytes.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterBytes.check_lower(value.bytes)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterBytes.write(value.bytes, buf)
+
+
 class SendOnchainFeeQuote:
     id: "str"
     expires_at: "int"
@@ -14572,7 +15187,7 @@ class SparkHtlcDetails:
 
     expiry_time: "int"
     """
-    The expiry time of the HTLC in seconds since the Unix epoch
+    The expiry time of the HTLC as a unix timestamp in seconds
     """
 
     status: "SparkHtlcStatus"
@@ -14694,7 +15309,7 @@ class SparkInvoiceDetails:
 
     expiry_time: "typing.Optional[int]"
     """
-    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.
     """
 
     description: "typing.Optional[str]"
@@ -14964,146 +15579,6 @@ class _UniffiConverterTypeTokenBalance(_UniffiConverterRustBuffer):
         _UniffiConverterTypeTokenMetadata.write(value.token_metadata, buf)
 
 
-class TokenConversionInfo:
-    pool_id: "str"
-    """
-    The pool id associated with the conversion
-    """
-
-    payment_id: "typing.Optional[str]"
-    """
-    The receiving payment id associated with the conversion
-    """
-
-    fee: "typing.Optional[U128]"
-    """
-    The fee paid for the conversion
-    Denominated in satoshis if converting from Bitcoin, otherwise in the token base units.
-    """
-
-    refund_identifier: "typing.Optional[str]"
-    """
-    The refund payment id if a refund payment was made
-    """
-
-    def __init__(self, *, pool_id: "str", payment_id: "typing.Optional[str]", fee: "typing.Optional[U128]", refund_identifier: "typing.Optional[str]"):
-        self.pool_id = pool_id
-        self.payment_id = payment_id
-        self.fee = fee
-        self.refund_identifier = refund_identifier
-
-    def __str__(self):
-        return "TokenConversionInfo(pool_id={}, payment_id={}, fee={}, refund_identifier={})".format(self.pool_id, self.payment_id, self.fee, self.refund_identifier)
-
-    def __eq__(self, other):
-        if self.pool_id != other.pool_id:
-            return False
-        if self.payment_id != other.payment_id:
-            return False
-        if self.fee != other.fee:
-            return False
-        if self.refund_identifier != other.refund_identifier:
-            return False
-        return True
-
-class _UniffiConverterTypeTokenConversionInfo(_UniffiConverterRustBuffer):
-    @staticmethod
-    def read(buf):
-        return TokenConversionInfo(
-            pool_id=_UniffiConverterString.read(buf),
-            payment_id=_UniffiConverterOptionalString.read(buf),
-            fee=_UniffiConverterOptionalTypeU128.read(buf),
-            refund_identifier=_UniffiConverterOptionalString.read(buf),
-        )
-
-    @staticmethod
-    def check_lower(value):
-        _UniffiConverterString.check_lower(value.pool_id)
-        _UniffiConverterOptionalString.check_lower(value.payment_id)
-        _UniffiConverterOptionalTypeU128.check_lower(value.fee)
-        _UniffiConverterOptionalString.check_lower(value.refund_identifier)
-
-    @staticmethod
-    def write(value, buf):
-        _UniffiConverterString.write(value.pool_id, buf)
-        _UniffiConverterOptionalString.write(value.payment_id, buf)
-        _UniffiConverterOptionalTypeU128.write(value.fee, buf)
-        _UniffiConverterOptionalString.write(value.refund_identifier, buf)
-
-
-class TokenConversionOptions:
-    """
-    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.
-    """
-
-    conversion_type: "TokenConversionType"
-    """
-    The type of token conversion to perform when fulfilling the payment
-    """
-
-    max_slippage_bps: "typing.Optional[int]"
-    """
-    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)`.
-    """
-
-    completion_timeout_secs: "typing.Optional[int]"
-    """
-    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.
-    """
-
-    def __init__(self, *, conversion_type: "TokenConversionType", max_slippage_bps: "typing.Optional[int]" = _DEFAULT, completion_timeout_secs: "typing.Optional[int]" = _DEFAULT):
-        self.conversion_type = conversion_type
-        if max_slippage_bps is _DEFAULT:
-            self.max_slippage_bps = None
-        else:
-            self.max_slippage_bps = max_slippage_bps
-        if completion_timeout_secs is _DEFAULT:
-            self.completion_timeout_secs = None
-        else:
-            self.completion_timeout_secs = completion_timeout_secs
-
-    def __str__(self):
-        return "TokenConversionOptions(conversion_type={}, max_slippage_bps={}, completion_timeout_secs={})".format(self.conversion_type, self.max_slippage_bps, self.completion_timeout_secs)
-
-    def __eq__(self, other):
-        if self.conversion_type != other.conversion_type:
-            return False
-        if self.max_slippage_bps != other.max_slippage_bps:
-            return False
-        if self.completion_timeout_secs != other.completion_timeout_secs:
-            return False
-        return True
-
-class _UniffiConverterTypeTokenConversionOptions(_UniffiConverterRustBuffer):
-    @staticmethod
-    def read(buf):
-        return TokenConversionOptions(
-            conversion_type=_UniffiConverterTypeTokenConversionType.read(buf),
-            max_slippage_bps=_UniffiConverterOptionalUInt32.read(buf),
-            completion_timeout_secs=_UniffiConverterOptionalUInt32.read(buf),
-        )
-
-    @staticmethod
-    def check_lower(value):
-        _UniffiConverterTypeTokenConversionType.check_lower(value.conversion_type)
-        _UniffiConverterOptionalUInt32.check_lower(value.max_slippage_bps)
-        _UniffiConverterOptionalUInt32.check_lower(value.completion_timeout_secs)
-
-    @staticmethod
-    def write(value, buf):
-        _UniffiConverterTypeTokenConversionType.write(value.conversion_type, buf)
-        _UniffiConverterOptionalUInt32.write(value.max_slippage_bps, buf)
-        _UniffiConverterOptionalUInt32.write(value.completion_timeout_secs, buf)
-
-
 class TokenMetadata:
     identifier: "str"
     issuer_public_key: "str"
@@ -16021,6 +16496,272 @@ class _UniffiConverterTypeChainServiceError(_UniffiConverterRustBuffer):
 
 
 
+class ConversionPurpose:
+    """
+    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.
+    """
+
+    def __init__(self):
+        raise RuntimeError("ConversionPurpose cannot be instantiated directly")
+
+    # Each enum variant is a nested class of the enum itself.
+    class ONGOING_PAYMENT:
+        """
+        Conversion is associated with an ongoing payment
+        """
+
+        payment_request: "str"
+        """
+        The payment request of the ongoing payment
+        """
+
+
+        def __init__(self,payment_request: "str"):
+            self.payment_request = payment_request
+
+        def __str__(self):
+            return "ConversionPurpose.ONGOING_PAYMENT(payment_request={})".format(self.payment_request)
+
+        def __eq__(self, other):
+            if not other.is_ongoing_payment():
+                return False
+            if self.payment_request != other.payment_request:
+                return False
+            return True
+    
+    class SELF_TRANSFER:
+        """
+        Conversion is for self-transfer
+        """
+
+
+        def __init__(self,):
+            pass
+
+        def __str__(self):
+            return "ConversionPurpose.SELF_TRANSFER()".format()
+
+        def __eq__(self, other):
+            if not other.is_self_transfer():
+                return False
+            return True
+    
+    
+
+    # For each variant, we have an `is_NAME` method for easily checking
+    # whether an instance is that variant.
+    def is_ongoing_payment(self) -> bool:
+        return isinstance(self, ConversionPurpose.ONGOING_PAYMENT)
+    def is_self_transfer(self) -> bool:
+        return isinstance(self, ConversionPurpose.SELF_TRANSFER)
+    
+
+# Now, a little trick - we make each nested variant class be a subclass of the main
+# enum class, so that method calls and instance checks etc will work intuitively.
+# We might be able to do this a little more neatly with a metaclass, but this'll do.
+ConversionPurpose.ONGOING_PAYMENT = type("ConversionPurpose.ONGOING_PAYMENT", (ConversionPurpose.ONGOING_PAYMENT, ConversionPurpose,), {})  # type: ignore
+ConversionPurpose.SELF_TRANSFER = type("ConversionPurpose.SELF_TRANSFER", (ConversionPurpose.SELF_TRANSFER, ConversionPurpose,), {})  # type: ignore
+
+
+
+
+class _UniffiConverterTypeConversionPurpose(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return ConversionPurpose.ONGOING_PAYMENT(
+                _UniffiConverterString.read(buf),
+            )
+        if variant == 2:
+            return ConversionPurpose.SELF_TRANSFER(
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value.is_ongoing_payment():
+            _UniffiConverterString.check_lower(value.payment_request)
+            return
+        if value.is_self_transfer():
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value.is_ongoing_payment():
+            buf.write_i32(1)
+            _UniffiConverterString.write(value.payment_request, buf)
+        if value.is_self_transfer():
+            buf.write_i32(2)
+
+
+
+
+
+
+
+class ConversionStatus(enum.Enum):
+    """
+    The status of the conversion
+    """
+
+    COMPLETED = 0
+    """
+    The conversion was successful
+    """
+
+    
+    REFUND_NEEDED = 1
+    """
+    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.
+    """
+
+    
+    REFUNDED = 2
+    """
+    The conversion failed and a refund was made
+    """
+
+    
+
+
+class _UniffiConverterTypeConversionStatus(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return ConversionStatus.COMPLETED
+        if variant == 2:
+            return ConversionStatus.REFUND_NEEDED
+        if variant == 3:
+            return ConversionStatus.REFUNDED
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == ConversionStatus.COMPLETED:
+            return
+        if value == ConversionStatus.REFUND_NEEDED:
+            return
+        if value == ConversionStatus.REFUNDED:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == ConversionStatus.COMPLETED:
+            buf.write_i32(1)
+        if value == ConversionStatus.REFUND_NEEDED:
+            buf.write_i32(2)
+        if value == ConversionStatus.REFUNDED:
+            buf.write_i32(3)
+
+
+
+
+
+
+
+class ConversionType:
+    def __init__(self):
+        raise RuntimeError("ConversionType cannot be instantiated directly")
+
+    # Each enum variant is a nested class of the enum itself.
+    class FROM_BITCOIN:
+        """
+        Converting from Bitcoin to a token
+        """
+
+
+        def __init__(self,):
+            pass
+
+        def __str__(self):
+            return "ConversionType.FROM_BITCOIN()".format()
+
+        def __eq__(self, other):
+            if not other.is_from_bitcoin():
+                return False
+            return True
+    
+    class TO_BITCOIN:
+        """
+        Converting from a token to Bitcoin
+        """
+
+        from_token_identifier: "str"
+
+        def __init__(self,from_token_identifier: "str"):
+            self.from_token_identifier = from_token_identifier
+
+        def __str__(self):
+            return "ConversionType.TO_BITCOIN(from_token_identifier={})".format(self.from_token_identifier)
+
+        def __eq__(self, other):
+            if not other.is_to_bitcoin():
+                return False
+            if self.from_token_identifier != other.from_token_identifier:
+                return False
+            return True
+    
+    
+
+    # For each variant, we have an `is_NAME` method for easily checking
+    # whether an instance is that variant.
+    def is_from_bitcoin(self) -> bool:
+        return isinstance(self, ConversionType.FROM_BITCOIN)
+    def is_to_bitcoin(self) -> bool:
+        return isinstance(self, ConversionType.TO_BITCOIN)
+    
+
+# Now, a little trick - we make each nested variant class be a subclass of the main
+# enum class, so that method calls and instance checks etc will work intuitively.
+# We might be able to do this a little more neatly with a metaclass, but this'll do.
+ConversionType.FROM_BITCOIN = type("ConversionType.FROM_BITCOIN", (ConversionType.FROM_BITCOIN, ConversionType,), {})  # type: ignore
+ConversionType.TO_BITCOIN = type("ConversionType.TO_BITCOIN", (ConversionType.TO_BITCOIN, ConversionType,), {})  # type: ignore
+
+
+
+
+class _UniffiConverterTypeConversionType(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return ConversionType.FROM_BITCOIN(
+            )
+        if variant == 2:
+            return ConversionType.TO_BITCOIN(
+                _UniffiConverterString.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value.is_from_bitcoin():
+            return
+        if value.is_to_bitcoin():
+            _UniffiConverterString.check_lower(value.from_token_identifier)
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value.is_from_bitcoin():
+            buf.write_i32(1)
+        if value.is_to_bitcoin():
+            buf.write_i32(2)
+            _UniffiConverterString.write(value.from_token_identifier, buf)
+
+
+
+
+
+
+
 class DepositClaimError:
     def __init__(self):
         raise RuntimeError("DepositClaimError cannot be instantiated directly")
@@ -16180,13 +16921,13 @@ class _UniffiConverterTypeDepositClaimError(_UniffiConverterRustBuffer):
 
 
 
-class ExternalPrivateKeySource:
+class ExternalSecretSource:
     """
-    FFI-safe representation of `spark_wallet::PrivateKeySource`
+    FFI-safe representation of `spark_wallet::SecretSource`
     """
 
     def __init__(self):
-        raise RuntimeError("ExternalPrivateKeySource cannot be instantiated directly")
+        raise RuntimeError("ExternalSecretSource cannot be instantiated directly")
 
     # Each enum variant is a nested class of the enum itself.
     class DERIVED:
@@ -16200,7 +16941,7 @@ class ExternalPrivateKeySource:
             self.node_id = node_id
 
         def __str__(self):
-            return "ExternalPrivateKeySource.DERIVED(node_id={})".format(self.node_id)
+            return "ExternalSecretSource.DERIVED(node_id={})".format(self.node_id)
 
         def __eq__(self, other):
             if not other.is_derived():
@@ -16214,13 +16955,13 @@ class ExternalPrivateKeySource:
         Encrypted private key
         """
 
-        key: "ExternalEncryptedPrivateKey"
+        key: "ExternalEncryptedSecret"
 
-        def __init__(self,key: "ExternalEncryptedPrivateKey"):
+        def __init__(self,key: "ExternalEncryptedSecret"):
             self.key = key
 
         def __str__(self):
-            return "ExternalPrivateKeySource.ENCRYPTED(key={})".format(self.key)
+            return "ExternalSecretSource.ENCRYPTED(key={})".format(self.key)
 
         def __eq__(self, other):
             if not other.is_encrypted():
@@ -16234,31 +16975,31 @@ class ExternalPrivateKeySource:
     # For each variant, we have an `is_NAME` method for easily checking
     # whether an instance is that variant.
     def is_derived(self) -> bool:
-        return isinstance(self, ExternalPrivateKeySource.DERIVED)
+        return isinstance(self, ExternalSecretSource.DERIVED)
     def is_encrypted(self) -> bool:
-        return isinstance(self, ExternalPrivateKeySource.ENCRYPTED)
+        return isinstance(self, ExternalSecretSource.ENCRYPTED)
     
 
 # Now, a little trick - we make each nested variant class be a subclass of the main
 # enum class, so that method calls and instance checks etc will work intuitively.
 # We might be able to do this a little more neatly with a metaclass, but this'll do.
-ExternalPrivateKeySource.DERIVED = type("ExternalPrivateKeySource.DERIVED", (ExternalPrivateKeySource.DERIVED, ExternalPrivateKeySource,), {})  # type: ignore
-ExternalPrivateKeySource.ENCRYPTED = type("ExternalPrivateKeySource.ENCRYPTED", (ExternalPrivateKeySource.ENCRYPTED, ExternalPrivateKeySource,), {})  # type: ignore
+ExternalSecretSource.DERIVED = type("ExternalSecretSource.DERIVED", (ExternalSecretSource.DERIVED, ExternalSecretSource,), {})  # type: ignore
+ExternalSecretSource.ENCRYPTED = type("ExternalSecretSource.ENCRYPTED", (ExternalSecretSource.ENCRYPTED, ExternalSecretSource,), {})  # type: ignore
 
 
 
 
-class _UniffiConverterTypeExternalPrivateKeySource(_UniffiConverterRustBuffer):
+class _UniffiConverterTypeExternalSecretSource(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
         variant = buf.read_i32()
         if variant == 1:
-            return ExternalPrivateKeySource.DERIVED(
+            return ExternalSecretSource.DERIVED(
                 _UniffiConverterTypeExternalTreeNodeId.read(buf),
             )
         if variant == 2:
-            return ExternalPrivateKeySource.ENCRYPTED(
-                _UniffiConverterTypeExternalEncryptedPrivateKey.read(buf),
+            return ExternalSecretSource.ENCRYPTED(
+                _UniffiConverterTypeExternalEncryptedSecret.read(buf),
             )
         raise InternalError("Raw enum value doesn't match any cases")
 
@@ -16268,7 +17009,7 @@ class _UniffiConverterTypeExternalPrivateKeySource(_UniffiConverterRustBuffer):
             _UniffiConverterTypeExternalTreeNodeId.check_lower(value.node_id)
             return
         if value.is_encrypted():
-            _UniffiConverterTypeExternalEncryptedPrivateKey.check_lower(value.key)
+            _UniffiConverterTypeExternalEncryptedSecret.check_lower(value.key)
             return
         raise ValueError(value)
 
@@ -16279,7 +17020,7 @@ class _UniffiConverterTypeExternalPrivateKeySource(_UniffiConverterRustBuffer):
             _UniffiConverterTypeExternalTreeNodeId.write(value.node_id, buf)
         if value.is_encrypted():
             buf.write_i32(2)
-            _UniffiConverterTypeExternalEncryptedPrivateKey.write(value.key, buf)
+            _UniffiConverterTypeExternalEncryptedSecret.write(value.key, buf)
 
 
 
@@ -16296,21 +17037,21 @@ class ExternalSecretToSplit:
         raise RuntimeError("ExternalSecretToSplit cannot be instantiated directly")
 
     # Each enum variant is a nested class of the enum itself.
-    class PRIVATE_KEY:
+    class SECRET_SOURCE:
         """
-        A private key to split
+        A secret source to split
         """
 
-        source: "ExternalPrivateKeySource"
+        source: "ExternalSecretSource"
 
-        def __init__(self,source: "ExternalPrivateKeySource"):
+        def __init__(self,source: "ExternalSecretSource"):
             self.source = source
 
         def __str__(self):
-            return "ExternalSecretToSplit.PRIVATE_KEY(source={})".format(self.source)
+            return "ExternalSecretToSplit.SECRET_SOURCE(source={})".format(self.source)
 
         def __eq__(self, other):
-            if not other.is_private_key():
+            if not other.is_secret_source():
                 return False
             if self.source != other.source:
                 return False
@@ -16340,8 +17081,8 @@ class ExternalSecretToSplit:
 
     # For each variant, we have an `is_NAME` method for easily checking
     # whether an instance is that variant.
-    def is_private_key(self) -> bool:
-        return isinstance(self, ExternalSecretToSplit.PRIVATE_KEY)
+    def is_secret_source(self) -> bool:
+        return isinstance(self, ExternalSecretToSplit.SECRET_SOURCE)
     def is_preimage(self) -> bool:
         return isinstance(self, ExternalSecretToSplit.PREIMAGE)
     
@@ -16349,7 +17090,7 @@ class ExternalSecretToSplit:
 # Now, a little trick - we make each nested variant class be a subclass of the main
 # enum class, so that method calls and instance checks etc will work intuitively.
 # We might be able to do this a little more neatly with a metaclass, but this'll do.
-ExternalSecretToSplit.PRIVATE_KEY = type("ExternalSecretToSplit.PRIVATE_KEY", (ExternalSecretToSplit.PRIVATE_KEY, ExternalSecretToSplit,), {})  # type: ignore
+ExternalSecretToSplit.SECRET_SOURCE = type("ExternalSecretToSplit.SECRET_SOURCE", (ExternalSecretToSplit.SECRET_SOURCE, ExternalSecretToSplit,), {})  # type: ignore
 ExternalSecretToSplit.PREIMAGE = type("ExternalSecretToSplit.PREIMAGE", (ExternalSecretToSplit.PREIMAGE, ExternalSecretToSplit,), {})  # type: ignore
 
 
@@ -16360,8 +17101,8 @@ class _UniffiConverterTypeExternalSecretToSplit(_UniffiConverterRustBuffer):
     def read(buf):
         variant = buf.read_i32()
         if variant == 1:
-            return ExternalSecretToSplit.PRIVATE_KEY(
-                _UniffiConverterTypeExternalPrivateKeySource.read(buf),
+            return ExternalSecretToSplit.SECRET_SOURCE(
+                _UniffiConverterTypeExternalSecretSource.read(buf),
             )
         if variant == 2:
             return ExternalSecretToSplit.PREIMAGE(
@@ -16371,8 +17112,8 @@ class _UniffiConverterTypeExternalSecretToSplit(_UniffiConverterRustBuffer):
 
     @staticmethod
     def check_lower(value):
-        if value.is_private_key():
-            _UniffiConverterTypeExternalPrivateKeySource.check_lower(value.source)
+        if value.is_secret_source():
+            _UniffiConverterTypeExternalSecretSource.check_lower(value.source)
             return
         if value.is_preimage():
             _UniffiConverterBytes.check_lower(value.data)
@@ -16381,9 +17122,9 @@ class _UniffiConverterTypeExternalSecretToSplit(_UniffiConverterRustBuffer):
 
     @staticmethod
     def write(value, buf):
-        if value.is_private_key():
+        if value.is_secret_source():
             buf.write_i32(1)
-            _UniffiConverterTypeExternalPrivateKeySource.write(value.source, buf)
+            _UniffiConverterTypeExternalSecretSource.write(value.source, buf)
         if value.is_preimage():
             buf.write_i32(2)
             _UniffiConverterBytes.write(value.data, buf)
@@ -16960,61 +17701,162 @@ class _UniffiConverterTypeInputType(_UniffiConverterRustBuffer):
 
 
 
-class KeySetType(enum.Enum):
-    DEFAULT = 0
-    
-    TAPROOT = 1
-    
-    NATIVE_SEGWIT = 2
+class KeySetType(enum.Enum):
+    DEFAULT = 0
+    
+    TAPROOT = 1
+    
+    NATIVE_SEGWIT = 2
+    
+    WRAPPED_SEGWIT = 3
+    
+    LEGACY = 4
+    
+
+
+class _UniffiConverterTypeKeySetType(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return KeySetType.DEFAULT
+        if variant == 2:
+            return KeySetType.TAPROOT
+        if variant == 3:
+            return KeySetType.NATIVE_SEGWIT
+        if variant == 4:
+            return KeySetType.WRAPPED_SEGWIT
+        if variant == 5:
+            return KeySetType.LEGACY
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == KeySetType.DEFAULT:
+            return
+        if value == KeySetType.TAPROOT:
+            return
+        if value == KeySetType.NATIVE_SEGWIT:
+            return
+        if value == KeySetType.WRAPPED_SEGWIT:
+            return
+        if value == KeySetType.LEGACY:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == KeySetType.DEFAULT:
+            buf.write_i32(1)
+        if value == KeySetType.TAPROOT:
+            buf.write_i32(2)
+        if value == KeySetType.NATIVE_SEGWIT:
+            buf.write_i32(3)
+        if value == KeySetType.WRAPPED_SEGWIT:
+            buf.write_i32(4)
+        if value == KeySetType.LEGACY:
+            buf.write_i32(5)
+
+
+
+
+
+
+
+class LnurlCallbackStatus:
+    """
+    The response from a LNURL-auth callback, indicating success or failure.
+    """
+
+    def __init__(self):
+        raise RuntimeError("LnurlCallbackStatus cannot be instantiated directly")
+
+    # Each enum variant is a nested class of the enum itself.
+    class OK:
+        """
+        On-wire format is: `{"status": "OK"}`
+        """
+
+
+        def __init__(self,):
+            pass
+
+        def __str__(self):
+            return "LnurlCallbackStatus.OK()".format()
+
+        def __eq__(self, other):
+            if not other.is_ok():
+                return False
+            return True
+    
+    class ERROR_STATUS:
+        """
+        On-wire format is: `{"status": "ERROR", "reason": "error details..."}`
+        """
+
+        error_details: "LnurlErrorDetails"
+
+        def __init__(self,error_details: "LnurlErrorDetails"):
+            self.error_details = error_details
+
+        def __str__(self):
+            return "LnurlCallbackStatus.ERROR_STATUS(error_details={})".format(self.error_details)
+
+        def __eq__(self, other):
+            if not other.is_error_status():
+                return False
+            if self.error_details != other.error_details:
+                return False
+            return True
     
-    WRAPPED_SEGWIT = 3
     
-    LEGACY = 4
+
+    # For each variant, we have an `is_NAME` method for easily checking
+    # whether an instance is that variant.
+    def is_ok(self) -> bool:
+        return isinstance(self, LnurlCallbackStatus.OK)
+    def is_error_status(self) -> bool:
+        return isinstance(self, LnurlCallbackStatus.ERROR_STATUS)
     
 
+# Now, a little trick - we make each nested variant class be a subclass of the main
+# enum class, so that method calls and instance checks etc will work intuitively.
+# We might be able to do this a little more neatly with a metaclass, but this'll do.
+LnurlCallbackStatus.OK = type("LnurlCallbackStatus.OK", (LnurlCallbackStatus.OK, LnurlCallbackStatus,), {})  # type: ignore
+LnurlCallbackStatus.ERROR_STATUS = type("LnurlCallbackStatus.ERROR_STATUS", (LnurlCallbackStatus.ERROR_STATUS, LnurlCallbackStatus,), {})  # type: ignore
+
 
-class _UniffiConverterTypeKeySetType(_UniffiConverterRustBuffer):
+
+
+class _UniffiConverterTypeLnurlCallbackStatus(_UniffiConverterRustBuffer):
     @staticmethod
     def read(buf):
         variant = buf.read_i32()
         if variant == 1:
-            return KeySetType.DEFAULT
+            return LnurlCallbackStatus.OK(
+            )
         if variant == 2:
-            return KeySetType.TAPROOT
-        if variant == 3:
-            return KeySetType.NATIVE_SEGWIT
-        if variant == 4:
-            return KeySetType.WRAPPED_SEGWIT
-        if variant == 5:
-            return KeySetType.LEGACY
+            return LnurlCallbackStatus.ERROR_STATUS(
+                _UniffiConverterTypeLnurlErrorDetails.read(buf),
+            )
         raise InternalError("Raw enum value doesn't match any cases")
 
     @staticmethod
     def check_lower(value):
-        if value == KeySetType.DEFAULT:
-            return
-        if value == KeySetType.TAPROOT:
-            return
-        if value == KeySetType.NATIVE_SEGWIT:
-            return
-        if value == KeySetType.WRAPPED_SEGWIT:
+        if value.is_ok():
             return
-        if value == KeySetType.LEGACY:
+        if value.is_error_status():
+            _UniffiConverterTypeLnurlErrorDetails.check_lower(value.error_details)
             return
         raise ValueError(value)
 
     @staticmethod
     def write(value, buf):
-        if value == KeySetType.DEFAULT:
+        if value.is_ok():
             buf.write_i32(1)
-        if value == KeySetType.TAPROOT:
+        if value.is_error_status():
             buf.write_i32(2)
-        if value == KeySetType.NATIVE_SEGWIT:
-            buf.write_i32(3)
-        if value == KeySetType.WRAPPED_SEGWIT:
-            buf.write_i32(4)
-        if value == KeySetType.LEGACY:
-            buf.write_i32(5)
+            _UniffiConverterTypeLnurlErrorDetails.write(value.error_details, buf)
 
 
 
@@ -17470,19 +18312,19 @@ class PaymentDetails:
         The HTLC transfer details if the payment fulfilled an HTLC transfer
         """
 
-        token_conversion_info: "typing.Optional[TokenConversionInfo]"
+        conversion_info: "typing.Optional[ConversionInfo]"
         """
-        The information for a token conversion
+        The information for a conversion
         """
 
 
-        def __init__(self,invoice_details: "typing.Optional[SparkInvoicePaymentDetails]", htlc_details: "typing.Optional[SparkHtlcDetails]", token_conversion_info: "typing.Optional[TokenConversionInfo]"):
+        def __init__(self,invoice_details: "typing.Optional[SparkInvoicePaymentDetails]", htlc_details: "typing.Optional[SparkHtlcDetails]", conversion_info: "typing.Optional[ConversionInfo]"):
             self.invoice_details = invoice_details
             self.htlc_details = htlc_details
-            self.token_conversion_info = token_conversion_info
+            self.conversion_info = conversion_info
 
         def __str__(self):
-            return "PaymentDetails.SPARK(invoice_details={}, htlc_details={}, token_conversion_info={})".format(self.invoice_details, self.htlc_details, self.token_conversion_info)
+            return "PaymentDetails.SPARK(invoice_details={}, htlc_details={}, conversion_info={})".format(self.invoice_details, self.htlc_details, self.conversion_info)
 
         def __eq__(self, other):
             if not other.is_spark():
@@ -17491,7 +18333,7 @@ class PaymentDetails:
                 return False
             if self.htlc_details != other.htlc_details:
                 return False
-            if self.token_conversion_info != other.token_conversion_info:
+            if self.conversion_info != other.conversion_info:
                 return False
             return True
     
@@ -17503,20 +18345,20 @@ class PaymentDetails:
         The invoice details if the payment fulfilled a spark invoice
         """
 
-        token_conversion_info: "typing.Optional[TokenConversionInfo]"
+        conversion_info: "typing.Optional[ConversionInfo]"
         """
-        The information for a token conversion
+        The information for a conversion
         """
 
 
-        def __init__(self,metadata: "TokenMetadata", tx_hash: "str", invoice_details: "typing.Optional[SparkInvoicePaymentDetails]", token_conversion_info: "typing.Optional[TokenConversionInfo]"):
+        def __init__(self,metadata: "TokenMetadata", tx_hash: "str", invoice_details: "typing.Optional[SparkInvoicePaymentDetails]", conversion_info: "typing.Optional[ConversionInfo]"):
             self.metadata = metadata
             self.tx_hash = tx_hash
             self.invoice_details = invoice_details
-            self.token_conversion_info = token_conversion_info
+            self.conversion_info = conversion_info
 
         def __str__(self):
-            return "PaymentDetails.TOKEN(metadata={}, tx_hash={}, invoice_details={}, token_conversion_info={})".format(self.metadata, self.tx_hash, self.invoice_details, self.token_conversion_info)
+            return "PaymentDetails.TOKEN(metadata={}, tx_hash={}, invoice_details={}, conversion_info={})".format(self.metadata, self.tx_hash, self.invoice_details, self.conversion_info)
 
         def __eq__(self, other):
             if not other.is_token():
@@ -17527,7 +18369,7 @@ class PaymentDetails:
                 return False
             if self.invoice_details != other.invoice_details:
                 return False
-            if self.token_conversion_info != other.token_conversion_info:
+            if self.conversion_info != other.conversion_info:
                 return False
             return True
     
@@ -17677,14 +18519,14 @@ class _UniffiConverterTypePaymentDetails(_UniffiConverterRustBuffer):
             return PaymentDetails.SPARK(
                 _UniffiConverterOptionalTypeSparkInvoicePaymentDetails.read(buf),
                 _UniffiConverterOptionalTypeSparkHtlcDetails.read(buf),
-                _UniffiConverterOptionalTypeTokenConversionInfo.read(buf),
+                _UniffiConverterOptionalTypeConversionInfo.read(buf),
             )
         if variant == 2:
             return PaymentDetails.TOKEN(
                 _UniffiConverterTypeTokenMetadata.read(buf),
                 _UniffiConverterString.read(buf),
                 _UniffiConverterOptionalTypeSparkInvoicePaymentDetails.read(buf),
-                _UniffiConverterOptionalTypeTokenConversionInfo.read(buf),
+                _UniffiConverterOptionalTypeConversionInfo.read(buf),
             )
         if variant == 3:
             return PaymentDetails.LIGHTNING(
@@ -17712,13 +18554,13 @@ class _UniffiConverterTypePaymentDetails(_UniffiConverterRustBuffer):
         if value.is_spark():
             _UniffiConverterOptionalTypeSparkInvoicePaymentDetails.check_lower(value.invoice_details)
             _UniffiConverterOptionalTypeSparkHtlcDetails.check_lower(value.htlc_details)
-            _UniffiConverterOptionalTypeTokenConversionInfo.check_lower(value.token_conversion_info)
+            _UniffiConverterOptionalTypeConversionInfo.check_lower(value.conversion_info)
             return
         if value.is_token():
             _UniffiConverterTypeTokenMetadata.check_lower(value.metadata)
             _UniffiConverterString.check_lower(value.tx_hash)
             _UniffiConverterOptionalTypeSparkInvoicePaymentDetails.check_lower(value.invoice_details)
-            _UniffiConverterOptionalTypeTokenConversionInfo.check_lower(value.token_conversion_info)
+            _UniffiConverterOptionalTypeConversionInfo.check_lower(value.conversion_info)
             return
         if value.is_lightning():
             _UniffiConverterOptionalString.check_lower(value.description)
@@ -17744,13 +18586,13 @@ class _UniffiConverterTypePaymentDetails(_UniffiConverterRustBuffer):
             buf.write_i32(1)
             _UniffiConverterOptionalTypeSparkInvoicePaymentDetails.write(value.invoice_details, buf)
             _UniffiConverterOptionalTypeSparkHtlcDetails.write(value.htlc_details, buf)
-            _UniffiConverterOptionalTypeTokenConversionInfo.write(value.token_conversion_info, buf)
+            _UniffiConverterOptionalTypeConversionInfo.write(value.conversion_info, buf)
         if value.is_token():
             buf.write_i32(2)
             _UniffiConverterTypeTokenMetadata.write(value.metadata, buf)
             _UniffiConverterString.write(value.tx_hash, buf)
             _UniffiConverterOptionalTypeSparkInvoicePaymentDetails.write(value.invoice_details, buf)
-            _UniffiConverterOptionalTypeTokenConversionInfo.write(value.token_conversion_info, buf)
+            _UniffiConverterOptionalTypeConversionInfo.write(value.conversion_info, buf)
         if value.is_lightning():
             buf.write_i32(3)
             _UniffiConverterOptionalString.write(value.description, buf)
@@ -18373,7 +19215,7 @@ class ReceivePaymentMethod:
 
         expiry_time: "typing.Optional[int]"
         """
-        The expiry time of the invoice in seconds since the Unix epoch
+        The expiry time of the invoice as a unix timestamp in seconds
         """
 
         description: "typing.Optional[str]"
@@ -18430,7 +19272,7 @@ class ReceivePaymentMethod:
         amount_sats: "typing.Optional[int]"
         expiry_secs: "typing.Optional[int]"
         """
-        The expiry time of the invoice in seconds
+        The expiry of the invoice as a duration in seconds
         """
 
 
@@ -20709,103 +21551,6 @@ class _UniffiConverterTypeSyncStorageError(_UniffiConverterRustBuffer):
 
 
 
-class TokenConversionType:
-    def __init__(self):
-        raise RuntimeError("TokenConversionType cannot be instantiated directly")
-
-    # Each enum variant is a nested class of the enum itself.
-    class FROM_BITCOIN:
-        """
-        Converting from Bitcoin to a token
-        """
-
-
-        def __init__(self,):
-            pass
-
-        def __str__(self):
-            return "TokenConversionType.FROM_BITCOIN()".format()
-
-        def __eq__(self, other):
-            if not other.is_from_bitcoin():
-                return False
-            return True
-    
-    class TO_BITCOIN:
-        """
-        Converting from a token to Bitcoin
-        """
-
-        from_token_identifier: "str"
-
-        def __init__(self,from_token_identifier: "str"):
-            self.from_token_identifier = from_token_identifier
-
-        def __str__(self):
-            return "TokenConversionType.TO_BITCOIN(from_token_identifier={})".format(self.from_token_identifier)
-
-        def __eq__(self, other):
-            if not other.is_to_bitcoin():
-                return False
-            if self.from_token_identifier != other.from_token_identifier:
-                return False
-            return True
-    
-    
-
-    # For each variant, we have an `is_NAME` method for easily checking
-    # whether an instance is that variant.
-    def is_from_bitcoin(self) -> bool:
-        return isinstance(self, TokenConversionType.FROM_BITCOIN)
-    def is_to_bitcoin(self) -> bool:
-        return isinstance(self, TokenConversionType.TO_BITCOIN)
-    
-
-# Now, a little trick - we make each nested variant class be a subclass of the main
-# enum class, so that method calls and instance checks etc will work intuitively.
-# We might be able to do this a little more neatly with a metaclass, but this'll do.
-TokenConversionType.FROM_BITCOIN = type("TokenConversionType.FROM_BITCOIN", (TokenConversionType.FROM_BITCOIN, TokenConversionType,), {})  # type: ignore
-TokenConversionType.TO_BITCOIN = type("TokenConversionType.TO_BITCOIN", (TokenConversionType.TO_BITCOIN, TokenConversionType,), {})  # type: ignore
-
-
-
-
-class _UniffiConverterTypeTokenConversionType(_UniffiConverterRustBuffer):
-    @staticmethod
-    def read(buf):
-        variant = buf.read_i32()
-        if variant == 1:
-            return TokenConversionType.FROM_BITCOIN(
-            )
-        if variant == 2:
-            return TokenConversionType.TO_BITCOIN(
-                _UniffiConverterString.read(buf),
-            )
-        raise InternalError("Raw enum value doesn't match any cases")
-
-    @staticmethod
-    def check_lower(value):
-        if value.is_from_bitcoin():
-            return
-        if value.is_to_bitcoin():
-            _UniffiConverterString.check_lower(value.from_token_identifier)
-            return
-        raise ValueError(value)
-
-    @staticmethod
-    def write(value, buf):
-        if value.is_from_bitcoin():
-            buf.write_i32(1)
-        if value.is_to_bitcoin():
-            buf.write_i32(2)
-            _UniffiConverterString.write(value.from_token_identifier, buf)
-
-
-
-
-
-
-
 class UpdateDepositPayload:
     def __init__(self):
         raise RuntimeError("UpdateDepositPayload cannot be instantiated directly")
@@ -21156,6 +21901,87 @@ class _UniffiConverterOptionalBytes(_UniffiConverterRustBuffer):
 
 
 
+class _UniffiConverterOptionalTypeConversionEstimate(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiConverterTypeConversionEstimate.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiConverterTypeConversionEstimate.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiConverterTypeConversionEstimate.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
+class _UniffiConverterOptionalTypeConversionInfo(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiConverterTypeConversionInfo.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiConverterTypeConversionInfo.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiConverterTypeConversionInfo.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
+class _UniffiConverterOptionalTypeConversionOptions(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiConverterTypeConversionOptions.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiConverterTypeConversionOptions.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiConverterTypeConversionOptions.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
 class _UniffiConverterOptionalTypeCredentials(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
@@ -21507,38 +22333,11 @@ class _UniffiConverterOptionalTypeSymbol(_UniffiConverterRustBuffer):
 
 
 
-class _UniffiConverterOptionalTypeTokenConversionInfo(_UniffiConverterRustBuffer):
-    @classmethod
-    def check_lower(cls, value):
-        if value is not None:
-            _UniffiConverterTypeTokenConversionInfo.check_lower(value)
-
-    @classmethod
-    def write(cls, value, buf):
-        if value is None:
-            buf.write_u8(0)
-            return
-
-        buf.write_u8(1)
-        _UniffiConverterTypeTokenConversionInfo.write(value, buf)
-
-    @classmethod
-    def read(cls, buf):
-        flag = buf.read_u8()
-        if flag == 0:
-            return None
-        elif flag == 1:
-            return _UniffiConverterTypeTokenConversionInfo.read(buf)
-        else:
-            raise InternalError("Unexpected flag byte for optional type")
-
-
-
-class _UniffiConverterOptionalTypeTokenConversionOptions(_UniffiConverterRustBuffer):
+class _UniffiConverterOptionalTypeAmount(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
         if value is not None:
-            _UniffiConverterTypeTokenConversionOptions.check_lower(value)
+            _UniffiConverterTypeAmount.check_lower(value)
 
     @classmethod
     def write(cls, value, buf):
@@ -21547,7 +22346,7 @@ class _UniffiConverterOptionalTypeTokenConversionOptions(_UniffiConverterRustBuf
             return
 
         buf.write_u8(1)
-        _UniffiConverterTypeTokenConversionOptions.write(value, buf)
+        _UniffiConverterTypeAmount.write(value, buf)
 
     @classmethod
     def read(cls, buf):
@@ -21555,17 +22354,17 @@ class _UniffiConverterOptionalTypeTokenConversionOptions(_UniffiConverterRustBuf
         if flag == 0:
             return None
         elif flag == 1:
-            return _UniffiConverterTypeTokenConversionOptions.read(buf)
+            return _UniffiConverterTypeAmount.read(buf)
         else:
             raise InternalError("Unexpected flag byte for optional type")
 
 
 
-class _UniffiConverterOptionalTypeAmount(_UniffiConverterRustBuffer):
+class _UniffiConverterOptionalTypeAssetFilter(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
         if value is not None:
-            _UniffiConverterTypeAmount.check_lower(value)
+            _UniffiConverterTypeAssetFilter.check_lower(value)
 
     @classmethod
     def write(cls, value, buf):
@@ -21574,7 +22373,7 @@ class _UniffiConverterOptionalTypeAmount(_UniffiConverterRustBuffer):
             return
 
         buf.write_u8(1)
-        _UniffiConverterTypeAmount.write(value, buf)
+        _UniffiConverterTypeAssetFilter.write(value, buf)
 
     @classmethod
     def read(cls, buf):
@@ -21582,17 +22381,17 @@ class _UniffiConverterOptionalTypeAmount(_UniffiConverterRustBuffer):
         if flag == 0:
             return None
         elif flag == 1:
-            return _UniffiConverterTypeAmount.read(buf)
+            return _UniffiConverterTypeAssetFilter.read(buf)
         else:
             raise InternalError("Unexpected flag byte for optional type")
 
 
 
-class _UniffiConverterOptionalTypeAssetFilter(_UniffiConverterRustBuffer):
+class _UniffiConverterOptionalTypeConversionPurpose(_UniffiConverterRustBuffer):
     @classmethod
     def check_lower(cls, value):
         if value is not None:
-            _UniffiConverterTypeAssetFilter.check_lower(value)
+            _UniffiConverterTypeConversionPurpose.check_lower(value)
 
     @classmethod
     def write(cls, value, buf):
@@ -21601,7 +22400,7 @@ class _UniffiConverterOptionalTypeAssetFilter(_UniffiConverterRustBuffer):
             return
 
         buf.write_u8(1)
-        _UniffiConverterTypeAssetFilter.write(value, buf)
+        _UniffiConverterTypeConversionPurpose.write(value, buf)
 
     @classmethod
     def read(cls, buf):
@@ -21609,7 +22408,7 @@ class _UniffiConverterOptionalTypeAssetFilter(_UniffiConverterRustBuffer):
         if flag == 0:
             return None
         elif flag == 1:
-            return _UniffiConverterTypeAssetFilter.read(buf)
+            return _UniffiConverterTypeConversionPurpose.read(buf)
         else:
             raise InternalError("Unexpected flag byte for optional type")
 
@@ -23072,12 +23871,16 @@ __all__ = [
     "BitcoinNetwork",
     "ChainApiType",
     "ChainServiceError",
+    "ConversionPurpose",
+    "ConversionStatus",
+    "ConversionType",
     "DepositClaimError",
-    "ExternalPrivateKeySource",
+    "ExternalSecretSource",
     "ExternalSecretToSplit",
     "Fee",
     "InputType",
     "KeySetType",
+    "LnurlCallbackStatus",
     "MaxFee",
     "Network",
     "OnchainConfirmationSpeed",
@@ -23102,7 +23905,6 @@ __all__ = [
     "SuccessAction",
     "SuccessActionProcessed",
     "SyncStorageError",
-    "TokenConversionType",
     "UpdateDepositPayload",
     "AesSuccessActionData",
     "AesSuccessActionDataDecrypted",
@@ -23130,13 +23932,16 @@ __all__ = [
     "Config",
     "ConnectRequest",
     "ConnectWithSignerRequest",
+    "ConversionEstimate",
+    "ConversionInfo",
+    "ConversionOptions",
     "CreateIssuerTokenRequest",
     "Credentials",
     "CurrencyInfo",
     "DepositInfo",
     "EcdsaSignatureBytes",
     "ExternalAggregateFrostRequest",
-    "ExternalEncryptedPrivateKey",
+    "ExternalEncryptedSecret",
     "ExternalFrostCommitments",
     "ExternalFrostSignature",
     "ExternalFrostSignatureShare",
@@ -23148,8 +23953,8 @@ __all__ = [
     "ExternalSigningCommitments",
     "ExternalTreeNodeId",
     "ExternalVerifiableSecretShare",
-    "FetchTokenConversionLimitsRequest",
-    "FetchTokenConversionLimitsResponse",
+    "FetchConversionLimitsRequest",
+    "FetchConversionLimitsResponse",
     "FiatCurrency",
     "FreezeIssuerTokenRequest",
     "FreezeIssuerTokenResponse",
@@ -23159,6 +23964,7 @@ __all__ = [
     "GetPaymentResponse",
     "GetTokensMetadataRequest",
     "GetTokensMetadataResponse",
+    "HashedMessageBytes",
     "IdentifierCommitmentPair",
     "IdentifierPublicKeyPair",
     "IdentifierSignaturePair",
@@ -23173,6 +23979,7 @@ __all__ = [
     "ListUnclaimedDepositsRequest",
     "ListUnclaimedDepositsResponse",
     "LnurlAuthRequestDetails",
+    "LnurlErrorDetails",
     "LnurlPayInfo",
     "LnurlPayRequest",
     "LnurlPayRequestDetails",
@@ -23185,6 +23992,7 @@ __all__ = [
     "LocaleOverrides",
     "LocalizedName",
     "LogEntry",
+    "MessageBytes",
     "MessageSuccessActionData",
     "MintIssuerTokenRequest",
     "OptimizationConfig",
@@ -23197,7 +24005,6 @@ __all__ = [
     "PrepareLnurlPayResponse",
     "PrepareSendPaymentRequest",
     "PrepareSendPaymentResponse",
-    "PrivateKeyBytes",
     "ProvisionalPayment",
     "PublicKeyBytes",
     "Rate",
@@ -23213,6 +24020,7 @@ __all__ = [
     "RegisterLightningAddressRequest",
     "RestResponse",
     "SchnorrSignatureBytes",
+    "SecretBytes",
     "SendOnchainFeeQuote",
     "SendOnchainSpeedFeeQuote",
     "SendPaymentRequest",
@@ -23230,8 +24038,6 @@ __all__ = [
     "SyncWalletRequest",
     "SyncWalletResponse",
     "TokenBalance",
-    "TokenConversionInfo",
-    "TokenConversionOptions",
     "TokenMetadata",
     "TxStatus",
     "UnfreezeIssuerTokenRequest",