@breeztech/breez-sdk-spark-react-native 0.18.0-dev4 → 0.18.0

package/cpp/generated/breez_sdk_spark.cpp

@@ -155,6 +155,22 @@ typedef void (*UniffiCallbackInterfaceExternalBreezSignerMethod6)(
     uint64_t uniffi_handle, RustBuffer message, RustBuffer path,
     UniffiForeignFutureCompleteRustBuffer uniffi_future_callback,
     uint64_t uniffi_callback_data, UniffiForeignFuture *uniffi_out_return);
+typedef void (*UniffiCallbackInterfaceExternalSigningSignerMethod0)(
+    uint64_t uniffi_handle, RustBuffer path,
+    UniffiForeignFutureCompleteRustBuffer uniffi_future_callback,
+    uint64_t uniffi_callback_data, UniffiForeignFuture *uniffi_out_return);
+typedef void (*UniffiCallbackInterfaceExternalSigningSignerMethod1)(
+    uint64_t uniffi_handle, RustBuffer message, RustBuffer path,
+    UniffiForeignFutureCompleteRustBuffer uniffi_future_callback,
+    uint64_t uniffi_callback_data, UniffiForeignFuture *uniffi_out_return);
+typedef void (*UniffiCallbackInterfaceExternalSigningSignerMethod2)(
+    uint64_t uniffi_handle, RustBuffer message, RustBuffer path,
+    UniffiForeignFutureCompleteRustBuffer uniffi_future_callback,
+    uint64_t uniffi_callback_data, UniffiForeignFuture *uniffi_out_return);
+typedef void (*UniffiCallbackInterfaceExternalSigningSignerMethod3)(
+    uint64_t uniffi_handle, RustBuffer hash, RustBuffer path,
+    UniffiForeignFutureCompleteRustBuffer uniffi_future_callback,
+    uint64_t uniffi_callback_data, UniffiForeignFuture *uniffi_out_return);
 typedef void (*UniffiCallbackInterfaceExternalSparkSignerMethod0)(
     uint64_t uniffi_handle,
     UniffiForeignFutureCompleteRustBuffer uniffi_future_callback,
@@ -418,6 +434,13 @@ typedef struct UniffiVTableCallbackInterfaceExternalBreezSigner {
   UniffiCallbackInterfaceExternalBreezSignerMethod6 hmac_sha256;
   UniffiCallbackInterfaceFree uniffi_free;
 } UniffiVTableCallbackInterfaceExternalBreezSigner;
+typedef struct UniffiVTableCallbackInterfaceExternalSigningSigner {
+  UniffiCallbackInterfaceExternalSigningSignerMethod0 derive_public_key;
+  UniffiCallbackInterfaceExternalSigningSignerMethod1 sign_ecdsa;
+  UniffiCallbackInterfaceExternalSigningSignerMethod2 sign_ecdsa_recoverable;
+  UniffiCallbackInterfaceExternalSigningSignerMethod3 sign_hash_schnorr;
+  UniffiCallbackInterfaceFree uniffi_free;
+} UniffiVTableCallbackInterfaceExternalSigningSigner;
 typedef struct UniffiVTableCallbackInterfaceExternalSparkSigner {
   UniffiCallbackInterfaceExternalSparkSignerMethod0 get_identity_public_key;
   UniffiCallbackInterfaceExternalSparkSignerMethod1 get_public_key_for_leaf;
@@ -684,6 +707,24 @@ uniffi_breez_sdk_spark_fn_method_externalbreezsigner_sign_hash_schnorr(
 /*handle*/ uint64_t
 uniffi_breez_sdk_spark_fn_method_externalbreezsigner_hmac_sha256(
     void *ptr, RustBuffer message, RustBuffer path);
+void *uniffi_breez_sdk_spark_fn_clone_externalsigningsigner(
+    void *ptr, RustCallStatus *uniffi_out_err);
+void uniffi_breez_sdk_spark_fn_free_externalsigningsigner(
+    void *ptr, RustCallStatus *uniffi_out_err);
+void uniffi_breez_sdk_spark_fn_init_callback_vtable_externalsigningsigner(
+    UniffiVTableCallbackInterfaceExternalSigningSigner *vtable);
+/*handle*/ uint64_t
+uniffi_breez_sdk_spark_fn_method_externalsigningsigner_derive_public_key(
+    void *ptr, RustBuffer path);
+/*handle*/ uint64_t
+uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_ecdsa(
+    void *ptr, RustBuffer message, RustBuffer path);
+/*handle*/ uint64_t
+uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_ecdsa_recoverable(
+    void *ptr, RustBuffer message, RustBuffer path);
+/*handle*/ uint64_t
+uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_hash_schnorr(
+    void *ptr, RustBuffer hash, RustBuffer path);
 void *uniffi_breez_sdk_spark_fn_clone_externalsparksigner(
     void *ptr, RustCallStatus *uniffi_out_err);
 void uniffi_breez_sdk_spark_fn_free_externalsparksigner(
@@ -835,6 +876,10 @@ void *uniffi_breez_sdk_spark_fn_constructor_sdkbuilder_new(
 void *uniffi_breez_sdk_spark_fn_constructor_sdkbuilder_new_with_signer(
     RustBuffer config, void *breez_signer, void *spark_signer,
     RustCallStatus *uniffi_out_err);
+void *
+uniffi_breez_sdk_spark_fn_constructor_sdkbuilder_new_with_signing_only_signer(
+    RustBuffer config, void *breez_signer, void *spark_signer,
+    RustCallStatus *uniffi_out_err);
 /*handle*/ uint64_t
 uniffi_breez_sdk_spark_fn_method_sdkbuilder_build(void *ptr);
 /*handle*/ uint64_t
@@ -1013,7 +1058,13 @@ void uniffi_breez_sdk_spark_fn_init_callback_vtable_logger(
 /*handle*/ uint64_t
 uniffi_breez_sdk_spark_fn_func_connect_with_signer(RustBuffer request);
 /*handle*/ uint64_t
+uniffi_breez_sdk_spark_fn_func_connect_with_signing_only_signer(
+    RustBuffer request);
+/*handle*/ uint64_t
 uniffi_breez_sdk_spark_fn_func_create_turnkey_signer(RustBuffer config);
+/*handle*/ uint64_t
+uniffi_breez_sdk_spark_fn_func_create_turnkey_signing_only_signer(
+    RustBuffer config);
 void *
 uniffi_breez_sdk_spark_fn_func_custom_storage(void *storage,
                                               RustCallStatus *uniffi_out_err);
@@ -1166,7 +1217,11 @@ void ffi_breez_sdk_spark_rust_future_complete_void(
     /*handle*/ uint64_t handle, RustCallStatus *uniffi_out_err);
 uint16_t uniffi_breez_sdk_spark_checksum_func_connect();
 uint16_t uniffi_breez_sdk_spark_checksum_func_connect_with_signer();
+uint16_t
+uniffi_breez_sdk_spark_checksum_func_connect_with_signing_only_signer();
 uint16_t uniffi_breez_sdk_spark_checksum_func_create_turnkey_signer();
+uint16_t
+uniffi_breez_sdk_spark_checksum_func_create_turnkey_signing_only_signer();
 uint16_t uniffi_breez_sdk_spark_checksum_func_custom_storage();
 uint16_t uniffi_breez_sdk_spark_checksum_func_default_config();
 uint16_t uniffi_breez_sdk_spark_checksum_func_default_external_signers();
@@ -1258,6 +1313,14 @@ uniffi_breez_sdk_spark_checksum_method_externalbreezsigner_sign_hash_schnorr();
 uint16_t
 uniffi_breez_sdk_spark_checksum_method_externalbreezsigner_hmac_sha256();
 uint16_t
+uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_derive_public_key();
+uint16_t
+uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_ecdsa();
+uint16_t
+uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_ecdsa_recoverable();
+uint16_t
+uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_hash_schnorr();
+uint16_t
 uniffi_breez_sdk_spark_checksum_method_externalsparksigner_get_identity_public_key();
 uint16_t
 uniffi_breez_sdk_spark_checksum_method_externalsparksigner_get_public_key_for_leaf();
@@ -1385,6 +1448,8 @@ uint16_t uniffi_breez_sdk_spark_checksum_constructor_passkeyclient_new();
 uint16_t uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new();
 uint16_t
 uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new_with_signer();
+uint16_t
+uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new_with_signing_only_signer();
 uint16_t uniffi_breez_sdk_spark_checksum_method_eventlistener_on_event();
 uint16_t uniffi_breez_sdk_spark_checksum_method_logger_log();
 uint32_t ffi_breez_sdk_spark_uniffi_contract_version();
@@ -2305,6 +2370,119 @@ static void cleanup() {
 } // namespace
   // uniffi::breez_sdk_spark::st::vtablecallbackinterfaceexternalbreezsigner::vtablecallbackinterfaceexternalbreezsigner::free
 
+// Callback function:
+// uniffi::breez_sdk_spark::st::vtablecallbackinterfaceexternalsigningsigner::vtablecallbackinterfaceexternalsigningsigner::free::UniffiCallbackInterfaceFree
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::breez_sdk_spark::st::
+    vtablecallbackinterfaceexternalsigningsigner::
+        vtablecallbackinterfaceexternalsigningsigner::free {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t)> rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_handle) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_handle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_handle);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_handle);
+
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback UniffiCallbackInterfaceFree: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void callback(uint64_t rs_handle) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_handle);
+}
+
+static UniffiCallbackInterfaceFree
+makeCallbackFunction( // uniffi::breez_sdk_spark::st::vtablecallbackinterfaceexternalsigningsigner::vtablecallbackinterfaceexternalsigningsigner::free
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](uint64_t rs_handle) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_handle](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_handle);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+
+    callInvoker->invokeNonBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeBreezSdkSpark, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::breez_sdk_spark::st::vtablecallbackinterfaceexternalsigningsigner::vtablecallbackinterfaceexternalsigningsigner::free
+
 // Callback function:
 // uniffi::breez_sdk_spark::st::vtablecallbackinterfaceexternalsparksigner::vtablecallbackinterfaceexternalsparksigner::free::UniffiCallbackInterfaceFree
 //
@@ -5235,8 +5413,608 @@ makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalb
         [callInvoker, callbackValue, rs_uniffiHandle, rs_path,
          rs_uniffiFutureCallback, rs_uniffiCallbackData,
          rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
-          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_path,
-               rs_uniffiFutureCallback, rs_uniffiCallbackData,
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_path,
+               rs_uniffiFutureCallback, rs_uniffiCallbackData,
+               rs_uniffiOutReturn);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+    callInvoker->invokeBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeBreezSdkSpark, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod0
+  // Implementation of callback function calling from Rust to JS
+  // CallbackInterfaceExternalBreezSignerMethod1
+
+// Callback function:
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod1::UniffiCallbackInterfaceExternalBreezSignerMethod1
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::breez_sdk_spark::cb::
+    callbackinterfaceexternalbreezsignermethod1 {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, RustBuffer, RustBuffer,
+                          UniffiForeignFutureCompleteRustBuffer, uint64_t,
+                          UniffiForeignFuture *)>
+    rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 RustBuffer rs_path,
+                 UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+                 uint64_t rs_uniffiCallbackData,
+                 UniffiForeignFuture *rs_uniffiOutReturn) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_uniffiHandle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
+  auto js_message = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_message);
+  auto js_path = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_path);
+  auto js_uniffiFutureCallback = uniffi::breez_sdk_spark::Bridging<
+      UniffiForeignFutureCompleteRustBuffer>::toJs(rt, callInvoker,
+                                                   rs_uniffiFutureCallback);
+  auto js_uniffiCallbackData = uniffi_jsi::Bridging<uint64_t>::toJs(
+      rt, callInvoker, rs_uniffiCallbackData);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_message, js_path,
+                                js_uniffiFutureCallback, js_uniffiCallbackData);
+
+    // return type is MutReference(Struct("ForeignFuture"))
+    // Finally, we need to copy the return value back into the Rust pointer.
+    *rs_uniffiOutReturn =
+        uniffi::breez_sdk_spark::Bridging<UniffiForeignFuture>::fromJs(
+            rt, callInvoker, uniffiResult);
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback "
+                 "UniffiCallbackInterfaceExternalBreezSignerMethod1: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void
+callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
+         UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+         uint64_t rs_uniffiCallbackData,
+         UniffiForeignFuture *rs_uniffiOutReturn) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_uniffiHandle, rs_message, rs_path, rs_uniffiFutureCallback,
+           rs_uniffiCallbackData, rs_uniffiOutReturn);
+}
+
+static UniffiCallbackInterfaceExternalBreezSignerMethod1
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod1
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 RustBuffer rs_path,
+                 UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+                 uint64_t rs_uniffiCallbackData,
+                 UniffiForeignFuture *rs_uniffiOutReturn) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_message, rs_path,
+         rs_uniffiFutureCallback, rs_uniffiCallbackData,
+         rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_message,
+               rs_path, rs_uniffiFutureCallback, rs_uniffiCallbackData,
+               rs_uniffiOutReturn);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+    callInvoker->invokeBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeBreezSdkSpark, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod1
+  // Implementation of callback function calling from Rust to JS
+  // CallbackInterfaceExternalBreezSignerMethod2
+
+// Callback function:
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod2::UniffiCallbackInterfaceExternalBreezSignerMethod2
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::breez_sdk_spark::cb::
+    callbackinterfaceexternalbreezsignermethod2 {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, RustBuffer, RustBuffer,
+                          UniffiForeignFutureCompleteRustBuffer, uint64_t,
+                          UniffiForeignFuture *)>
+    rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 RustBuffer rs_path,
+                 UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+                 uint64_t rs_uniffiCallbackData,
+                 UniffiForeignFuture *rs_uniffiOutReturn) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_uniffiHandle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
+  auto js_message = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_message);
+  auto js_path = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_path);
+  auto js_uniffiFutureCallback = uniffi::breez_sdk_spark::Bridging<
+      UniffiForeignFutureCompleteRustBuffer>::toJs(rt, callInvoker,
+                                                   rs_uniffiFutureCallback);
+  auto js_uniffiCallbackData = uniffi_jsi::Bridging<uint64_t>::toJs(
+      rt, callInvoker, rs_uniffiCallbackData);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_message, js_path,
+                                js_uniffiFutureCallback, js_uniffiCallbackData);
+
+    // return type is MutReference(Struct("ForeignFuture"))
+    // Finally, we need to copy the return value back into the Rust pointer.
+    *rs_uniffiOutReturn =
+        uniffi::breez_sdk_spark::Bridging<UniffiForeignFuture>::fromJs(
+            rt, callInvoker, uniffiResult);
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback "
+                 "UniffiCallbackInterfaceExternalBreezSignerMethod2: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void
+callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
+         UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+         uint64_t rs_uniffiCallbackData,
+         UniffiForeignFuture *rs_uniffiOutReturn) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_uniffiHandle, rs_message, rs_path, rs_uniffiFutureCallback,
+           rs_uniffiCallbackData, rs_uniffiOutReturn);
+}
+
+static UniffiCallbackInterfaceExternalBreezSignerMethod2
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod2
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 RustBuffer rs_path,
+                 UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+                 uint64_t rs_uniffiCallbackData,
+                 UniffiForeignFuture *rs_uniffiOutReturn) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_message, rs_path,
+         rs_uniffiFutureCallback, rs_uniffiCallbackData,
+         rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_message,
+               rs_path, rs_uniffiFutureCallback, rs_uniffiCallbackData,
+               rs_uniffiOutReturn);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+    callInvoker->invokeBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeBreezSdkSpark, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod2
+  // Implementation of callback function calling from Rust to JS
+  // CallbackInterfaceExternalBreezSignerMethod3
+
+// Callback function:
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod3::UniffiCallbackInterfaceExternalBreezSignerMethod3
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::breez_sdk_spark::cb::
+    callbackinterfaceexternalbreezsignermethod3 {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, RustBuffer, RustBuffer,
+                          UniffiForeignFutureCompleteRustBuffer, uint64_t,
+                          UniffiForeignFuture *)>
+    rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 RustBuffer rs_path,
+                 UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+                 uint64_t rs_uniffiCallbackData,
+                 UniffiForeignFuture *rs_uniffiOutReturn) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_uniffiHandle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
+  auto js_message = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_message);
+  auto js_path = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_path);
+  auto js_uniffiFutureCallback = uniffi::breez_sdk_spark::Bridging<
+      UniffiForeignFutureCompleteRustBuffer>::toJs(rt, callInvoker,
+                                                   rs_uniffiFutureCallback);
+  auto js_uniffiCallbackData = uniffi_jsi::Bridging<uint64_t>::toJs(
+      rt, callInvoker, rs_uniffiCallbackData);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_message, js_path,
+                                js_uniffiFutureCallback, js_uniffiCallbackData);
+
+    // return type is MutReference(Struct("ForeignFuture"))
+    // Finally, we need to copy the return value back into the Rust pointer.
+    *rs_uniffiOutReturn =
+        uniffi::breez_sdk_spark::Bridging<UniffiForeignFuture>::fromJs(
+            rt, callInvoker, uniffiResult);
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback "
+                 "UniffiCallbackInterfaceExternalBreezSignerMethod3: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void
+callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
+         UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+         uint64_t rs_uniffiCallbackData,
+         UniffiForeignFuture *rs_uniffiOutReturn) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_uniffiHandle, rs_message, rs_path, rs_uniffiFutureCallback,
+           rs_uniffiCallbackData, rs_uniffiOutReturn);
+}
+
+static UniffiCallbackInterfaceExternalBreezSignerMethod3
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod3
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 RustBuffer rs_path,
+                 UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+                 uint64_t rs_uniffiCallbackData,
+                 UniffiForeignFuture *rs_uniffiOutReturn) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_message, rs_path,
+         rs_uniffiFutureCallback, rs_uniffiCallbackData,
+         rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_message,
+               rs_path, rs_uniffiFutureCallback, rs_uniffiCallbackData,
+               rs_uniffiOutReturn);
+        };
+    // We'll then call that lambda from the callInvoker which will
+    // look after calling it on the correct thread.
+    callInvoker->invokeBlocking(rt, jsLambda);
+  };
+  return callback;
+}
+
+// This method is called from the destructor of NativeBreezSdkSpark, which only
+// happens when the jsi::Runtime is being destroyed.
+static void cleanup() {
+  // The lambda holds a reference to the the Runtime, so when this is nulled
+  // out, then the pointer will no longer be left dangling.
+  rsLambda = nullptr;
+}
+} // namespace
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod3
+  // Implementation of callback function calling from Rust to JS
+  // CallbackInterfaceExternalBreezSignerMethod4
+
+// Callback function:
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod4::UniffiCallbackInterfaceExternalBreezSignerMethod4
+//
+// We have the following constraints:
+// - we need to pass a function pointer to Rust.
+// - we need a jsi::Runtime and jsi::Function to call into JS.
+// - function pointers can't store state, so we can't use a lamda.
+//
+// For this, we store a lambda as a global, as `rsLambda`. The `callback`
+// function calls the lambda, which itself calls the `body` which then calls
+// into JS.
+//
+// We then give the `callback` function pointer to Rust which will call the
+// lambda sometime in the future.
+namespace uniffi::breez_sdk_spark::cb::
+    callbackinterfaceexternalbreezsignermethod4 {
+using namespace facebook;
+
+// We need to store a lambda in a global so we can call it from
+// a function pointer. The function pointer is passed to Rust.
+static std::function<void(uint64_t, RustBuffer, RustBuffer,
+                          UniffiForeignFutureCompleteRustBuffer, uint64_t,
+                          UniffiForeignFuture *)>
+    rsLambda = nullptr;
+
+// This is the main body of the callback. It's called from the lambda,
+// which itself is called from the callback function which is passed to Rust.
+static void body(jsi::Runtime &rt,
+                 std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+                 std::shared_ptr<jsi::Value> callbackValue,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 RustBuffer rs_path,
+                 UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+                 uint64_t rs_uniffiCallbackData,
+                 UniffiForeignFuture *rs_uniffiOutReturn) {
+
+  // Convert the arguments from Rust, into jsi::Values.
+  // We'll use the Bridging class to do this…
+  auto js_uniffiHandle =
+      uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
+  auto js_message = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_message);
+  auto js_path = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_path);
+  auto js_uniffiFutureCallback = uniffi::breez_sdk_spark::Bridging<
+      UniffiForeignFutureCompleteRustBuffer>::toJs(rt, callInvoker,
+                                                   rs_uniffiFutureCallback);
+  auto js_uniffiCallbackData = uniffi_jsi::Bridging<uint64_t>::toJs(
+      rt, callInvoker, rs_uniffiCallbackData);
+
+  // Now we are ready to call the callback.
+  // We are already on the JS thread, because this `body` function was
+  // invoked from the CallInvoker.
+  try {
+    // Getting the callback function
+    auto cb = callbackValue->asObject(rt).asFunction(rt);
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_message, js_path,
+                                js_uniffiFutureCallback, js_uniffiCallbackData);
+
+    // return type is MutReference(Struct("ForeignFuture"))
+    // Finally, we need to copy the return value back into the Rust pointer.
+    *rs_uniffiOutReturn =
+        uniffi::breez_sdk_spark::Bridging<UniffiForeignFuture>::fromJs(
+            rt, callInvoker, uniffiResult);
+  } catch (const jsi::JSError &error) {
+    std::cout << "Error in callback "
+                 "UniffiCallbackInterfaceExternalBreezSignerMethod4: "
+              << error.what() << std::endl;
+    throw error;
+  }
+}
+
+static void
+callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
+         UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+         uint64_t rs_uniffiCallbackData,
+         UniffiForeignFuture *rs_uniffiOutReturn) {
+  // If the runtime has shutdown, then there is no point in trying to
+  // call into Javascript. BUT how do we tell if the runtime has shutdown?
+  //
+  // Answer: the module destructor calls into callback `cleanup` method,
+  // which nulls out the rsLamda.
+  //
+  // If rsLamda is null, then there is no runtime to call into.
+  if (rsLambda == nullptr) {
+    // This only occurs when destructors are calling into Rust free/drop,
+    // which causes the JS callback to be dropped.
+    return;
+  }
+
+  // The runtime, the actual callback jsi::funtion, and the callInvoker
+  // are all in the lambda.
+  rsLambda(rs_uniffiHandle, rs_message, rs_path, rs_uniffiFutureCallback,
+           rs_uniffiCallbackData, rs_uniffiOutReturn);
+}
+
+static UniffiCallbackInterfaceExternalBreezSignerMethod4
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod4
+    jsi::Runtime &rt,
+    std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
+    const jsi::Value &value) {
+  if (rsLambda != nullptr) {
+    // `makeCallbackFunction` is called in two circumstances:
+    //
+    // 1. at startup, when initializing callback interface vtables.
+    // 2. when polling futures. This happens at least once per future that is
+    //    exposed to Javascript. We know that this is always the same function,
+    //    `uniffiFutureContinuationCallback` in `async-rust-calls.ts`.
+    //
+    // We can therefore return the callback function without making anything
+    // new if we've been initialized already.
+    return callback;
+  }
+  auto callbackFunction = value.asObject(rt).asFunction(rt);
+  auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
+  rsLambda = [&rt, callInvoker, callbackValue](
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 RustBuffer rs_path,
+                 UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
+                 uint64_t rs_uniffiCallbackData,
+                 UniffiForeignFuture *rs_uniffiOutReturn) {
+    // We immediately make a lambda which will do the work of transforming the
+    // arguments into JSI values and calling the callback.
+    uniffi_runtime::UniffiCallFunc jsLambda =
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_message, rs_path,
+         rs_uniffiFutureCallback, rs_uniffiCallbackData,
+         rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_message,
+               rs_path, rs_uniffiFutureCallback, rs_uniffiCallbackData,
                rs_uniffiOutReturn);
         };
     // We'll then call that lambda from the callInvoker which will
@@ -5254,12 +6032,12 @@ static void cleanup() {
   rsLambda = nullptr;
 }
 } // namespace
-  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod0
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod4
   // Implementation of callback function calling from Rust to JS
-  // CallbackInterfaceExternalBreezSignerMethod1
+  // CallbackInterfaceExternalBreezSignerMethod5
 
 // Callback function:
-// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod1::UniffiCallbackInterfaceExternalBreezSignerMethod1
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod5::UniffiCallbackInterfaceExternalBreezSignerMethod5
 //
 // We have the following constraints:
 // - we need to pass a function pointer to Rust.
@@ -5273,7 +6051,7 @@ static void cleanup() {
 // We then give the `callback` function pointer to Rust which will call the
 // lambda sometime in the future.
 namespace uniffi::breez_sdk_spark::cb::
-    callbackinterfaceexternalbreezsignermethod1 {
+    callbackinterfaceexternalbreezsignermethod5 {
 using namespace facebook;
 
 // We need to store a lambda in a global so we can call it from
@@ -5288,7 +6066,7 @@ static std::function<void(uint64_t, RustBuffer, RustBuffer,
 static void body(jsi::Runtime &rt,
                  std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
                  std::shared_ptr<jsi::Value> callbackValue,
-                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_hash,
                  RustBuffer rs_path,
                  UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
                  uint64_t rs_uniffiCallbackData,
@@ -5298,8 +6076,8 @@ static void body(jsi::Runtime &rt,
   // We'll use the Bridging class to do this…
   auto js_uniffiHandle =
       uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
-  auto js_message = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
-      rt, callInvoker, rs_message);
+  auto js_hash = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_hash);
   auto js_path = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
       rt, callInvoker, rs_path);
   auto js_uniffiFutureCallback = uniffi::breez_sdk_spark::Bridging<
@@ -5314,7 +6092,7 @@ static void body(jsi::Runtime &rt,
   try {
     // Getting the callback function
     auto cb = callbackValue->asObject(rt).asFunction(rt);
-    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_message, js_path,
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_hash, js_path,
                                 js_uniffiFutureCallback, js_uniffiCallbackData);
 
     // return type is MutReference(Struct("ForeignFuture"))
@@ -5324,14 +6102,14 @@ static void body(jsi::Runtime &rt,
             rt, callInvoker, uniffiResult);
   } catch (const jsi::JSError &error) {
     std::cout << "Error in callback "
-                 "UniffiCallbackInterfaceExternalBreezSignerMethod1: "
+                 "UniffiCallbackInterfaceExternalBreezSignerMethod5: "
               << error.what() << std::endl;
     throw error;
   }
 }
 
 static void
-callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
+callback(uint64_t rs_uniffiHandle, RustBuffer rs_hash, RustBuffer rs_path,
          UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
          uint64_t rs_uniffiCallbackData,
          UniffiForeignFuture *rs_uniffiOutReturn) {
@@ -5350,12 +6128,12 @@ callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
 
   // The runtime, the actual callback jsi::funtion, and the callInvoker
   // are all in the lambda.
-  rsLambda(rs_uniffiHandle, rs_message, rs_path, rs_uniffiFutureCallback,
+  rsLambda(rs_uniffiHandle, rs_hash, rs_path, rs_uniffiFutureCallback,
            rs_uniffiCallbackData, rs_uniffiOutReturn);
 }
 
-static UniffiCallbackInterfaceExternalBreezSignerMethod1
-makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod1
+static UniffiCallbackInterfaceExternalBreezSignerMethod5
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod5
     jsi::Runtime &rt,
     std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
     const jsi::Value &value) {
@@ -5374,7 +6152,7 @@ makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalb
   auto callbackFunction = value.asObject(rt).asFunction(rt);
   auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
   rsLambda = [&rt, callInvoker, callbackValue](
-                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_hash,
                  RustBuffer rs_path,
                  UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
                  uint64_t rs_uniffiCallbackData,
@@ -5382,10 +6160,10 @@ makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalb
     // We immediately make a lambda which will do the work of transforming the
     // arguments into JSI values and calling the callback.
     uniffi_runtime::UniffiCallFunc jsLambda =
-        [callInvoker, callbackValue, rs_uniffiHandle, rs_message, rs_path,
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_hash, rs_path,
          rs_uniffiFutureCallback, rs_uniffiCallbackData,
          rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
-          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_message,
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_hash,
                rs_path, rs_uniffiFutureCallback, rs_uniffiCallbackData,
                rs_uniffiOutReturn);
         };
@@ -5404,12 +6182,12 @@ static void cleanup() {
   rsLambda = nullptr;
 }
 } // namespace
-  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod1
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod5
   // Implementation of callback function calling from Rust to JS
-  // CallbackInterfaceExternalBreezSignerMethod2
+  // CallbackInterfaceExternalBreezSignerMethod6
 
 // Callback function:
-// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod2::UniffiCallbackInterfaceExternalBreezSignerMethod2
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod6::UniffiCallbackInterfaceExternalBreezSignerMethod6
 //
 // We have the following constraints:
 // - we need to pass a function pointer to Rust.
@@ -5423,7 +6201,7 @@ static void cleanup() {
 // We then give the `callback` function pointer to Rust which will call the
 // lambda sometime in the future.
 namespace uniffi::breez_sdk_spark::cb::
-    callbackinterfaceexternalbreezsignermethod2 {
+    callbackinterfaceexternalbreezsignermethod6 {
 using namespace facebook;
 
 // We need to store a lambda in a global so we can call it from
@@ -5474,7 +6252,7 @@ static void body(jsi::Runtime &rt,
             rt, callInvoker, uniffiResult);
   } catch (const jsi::JSError &error) {
     std::cout << "Error in callback "
-                 "UniffiCallbackInterfaceExternalBreezSignerMethod2: "
+                 "UniffiCallbackInterfaceExternalBreezSignerMethod6: "
               << error.what() << std::endl;
     throw error;
   }
@@ -5504,8 +6282,8 @@ callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
            rs_uniffiCallbackData, rs_uniffiOutReturn);
 }
 
-static UniffiCallbackInterfaceExternalBreezSignerMethod2
-makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod2
+static UniffiCallbackInterfaceExternalBreezSignerMethod6
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod6
     jsi::Runtime &rt,
     std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
     const jsi::Value &value) {
@@ -5554,12 +6332,12 @@ static void cleanup() {
   rsLambda = nullptr;
 }
 } // namespace
-  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod2
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod6
   // Implementation of callback function calling from Rust to JS
-  // CallbackInterfaceExternalBreezSignerMethod3
+  // CallbackInterfaceExternalSigningSignerMethod0
 
 // Callback function:
-// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod3::UniffiCallbackInterfaceExternalBreezSignerMethod3
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod0::UniffiCallbackInterfaceExternalSigningSignerMethod0
 //
 // We have the following constraints:
 // - we need to pass a function pointer to Rust.
@@ -5573,12 +6351,12 @@ static void cleanup() {
 // We then give the `callback` function pointer to Rust which will call the
 // lambda sometime in the future.
 namespace uniffi::breez_sdk_spark::cb::
-    callbackinterfaceexternalbreezsignermethod3 {
+    callbackinterfaceexternalsigningsignermethod0 {
 using namespace facebook;
 
 // We need to store a lambda in a global so we can call it from
 // a function pointer. The function pointer is passed to Rust.
-static std::function<void(uint64_t, RustBuffer, RustBuffer,
+static std::function<void(uint64_t, RustBuffer,
                           UniffiForeignFutureCompleteRustBuffer, uint64_t,
                           UniffiForeignFuture *)>
     rsLambda = nullptr;
@@ -5588,8 +6366,7 @@ static std::function<void(uint64_t, RustBuffer, RustBuffer,
 static void body(jsi::Runtime &rt,
                  std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
                  std::shared_ptr<jsi::Value> callbackValue,
-                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
-                 RustBuffer rs_path,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_path,
                  UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
                  uint64_t rs_uniffiCallbackData,
                  UniffiForeignFuture *rs_uniffiOutReturn) {
@@ -5598,8 +6375,6 @@ static void body(jsi::Runtime &rt,
   // We'll use the Bridging class to do this…
   auto js_uniffiHandle =
       uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
-  auto js_message = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
-      rt, callInvoker, rs_message);
   auto js_path = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
       rt, callInvoker, rs_path);
   auto js_uniffiFutureCallback = uniffi::breez_sdk_spark::Bridging<
@@ -5614,7 +6389,7 @@ static void body(jsi::Runtime &rt,
   try {
     // Getting the callback function
     auto cb = callbackValue->asObject(rt).asFunction(rt);
-    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_message, js_path,
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_path,
                                 js_uniffiFutureCallback, js_uniffiCallbackData);
 
     // return type is MutReference(Struct("ForeignFuture"))
@@ -5624,14 +6399,14 @@ static void body(jsi::Runtime &rt,
             rt, callInvoker, uniffiResult);
   } catch (const jsi::JSError &error) {
     std::cout << "Error in callback "
-                 "UniffiCallbackInterfaceExternalBreezSignerMethod3: "
+                 "UniffiCallbackInterfaceExternalSigningSignerMethod0: "
               << error.what() << std::endl;
     throw error;
   }
 }
 
 static void
-callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
+callback(uint64_t rs_uniffiHandle, RustBuffer rs_path,
          UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
          uint64_t rs_uniffiCallbackData,
          UniffiForeignFuture *rs_uniffiOutReturn) {
@@ -5650,12 +6425,12 @@ callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
 
   // The runtime, the actual callback jsi::funtion, and the callInvoker
   // are all in the lambda.
-  rsLambda(rs_uniffiHandle, rs_message, rs_path, rs_uniffiFutureCallback,
+  rsLambda(rs_uniffiHandle, rs_path, rs_uniffiFutureCallback,
            rs_uniffiCallbackData, rs_uniffiOutReturn);
 }
 
-static UniffiCallbackInterfaceExternalBreezSignerMethod3
-makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod3
+static UniffiCallbackInterfaceExternalSigningSignerMethod0
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod0
     jsi::Runtime &rt,
     std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
     const jsi::Value &value) {
@@ -5674,19 +6449,18 @@ makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalb
   auto callbackFunction = value.asObject(rt).asFunction(rt);
   auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
   rsLambda = [&rt, callInvoker, callbackValue](
-                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
-                 RustBuffer rs_path,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_path,
                  UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
                  uint64_t rs_uniffiCallbackData,
                  UniffiForeignFuture *rs_uniffiOutReturn) {
     // We immediately make a lambda which will do the work of transforming the
     // arguments into JSI values and calling the callback.
     uniffi_runtime::UniffiCallFunc jsLambda =
-        [callInvoker, callbackValue, rs_uniffiHandle, rs_message, rs_path,
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_path,
          rs_uniffiFutureCallback, rs_uniffiCallbackData,
          rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
-          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_message,
-               rs_path, rs_uniffiFutureCallback, rs_uniffiCallbackData,
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_path,
+               rs_uniffiFutureCallback, rs_uniffiCallbackData,
                rs_uniffiOutReturn);
         };
     // We'll then call that lambda from the callInvoker which will
@@ -5704,12 +6478,12 @@ static void cleanup() {
   rsLambda = nullptr;
 }
 } // namespace
-  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod3
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod0
   // Implementation of callback function calling from Rust to JS
-  // CallbackInterfaceExternalBreezSignerMethod4
+  // CallbackInterfaceExternalSigningSignerMethod1
 
 // Callback function:
-// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod4::UniffiCallbackInterfaceExternalBreezSignerMethod4
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod1::UniffiCallbackInterfaceExternalSigningSignerMethod1
 //
 // We have the following constraints:
 // - we need to pass a function pointer to Rust.
@@ -5723,7 +6497,7 @@ static void cleanup() {
 // We then give the `callback` function pointer to Rust which will call the
 // lambda sometime in the future.
 namespace uniffi::breez_sdk_spark::cb::
-    callbackinterfaceexternalbreezsignermethod4 {
+    callbackinterfaceexternalsigningsignermethod1 {
 using namespace facebook;
 
 // We need to store a lambda in a global so we can call it from
@@ -5774,7 +6548,7 @@ static void body(jsi::Runtime &rt,
             rt, callInvoker, uniffiResult);
   } catch (const jsi::JSError &error) {
     std::cout << "Error in callback "
-                 "UniffiCallbackInterfaceExternalBreezSignerMethod4: "
+                 "UniffiCallbackInterfaceExternalSigningSignerMethod1: "
               << error.what() << std::endl;
     throw error;
   }
@@ -5804,8 +6578,8 @@ callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
            rs_uniffiCallbackData, rs_uniffiOutReturn);
 }
 
-static UniffiCallbackInterfaceExternalBreezSignerMethod4
-makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod4
+static UniffiCallbackInterfaceExternalSigningSignerMethod1
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod1
     jsi::Runtime &rt,
     std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
     const jsi::Value &value) {
@@ -5854,12 +6628,12 @@ static void cleanup() {
   rsLambda = nullptr;
 }
 } // namespace
-  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod4
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod1
   // Implementation of callback function calling from Rust to JS
-  // CallbackInterfaceExternalBreezSignerMethod5
+  // CallbackInterfaceExternalSigningSignerMethod2
 
 // Callback function:
-// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod5::UniffiCallbackInterfaceExternalBreezSignerMethod5
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod2::UniffiCallbackInterfaceExternalSigningSignerMethod2
 //
 // We have the following constraints:
 // - we need to pass a function pointer to Rust.
@@ -5873,7 +6647,7 @@ static void cleanup() {
 // We then give the `callback` function pointer to Rust which will call the
 // lambda sometime in the future.
 namespace uniffi::breez_sdk_spark::cb::
-    callbackinterfaceexternalbreezsignermethod5 {
+    callbackinterfaceexternalsigningsignermethod2 {
 using namespace facebook;
 
 // We need to store a lambda in a global so we can call it from
@@ -5888,7 +6662,7 @@ static std::function<void(uint64_t, RustBuffer, RustBuffer,
 static void body(jsi::Runtime &rt,
                  std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
                  std::shared_ptr<jsi::Value> callbackValue,
-                 uint64_t rs_uniffiHandle, RustBuffer rs_hash,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
                  RustBuffer rs_path,
                  UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
                  uint64_t rs_uniffiCallbackData,
@@ -5898,8 +6672,8 @@ static void body(jsi::Runtime &rt,
   // We'll use the Bridging class to do this…
   auto js_uniffiHandle =
       uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
-  auto js_hash = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
-      rt, callInvoker, rs_hash);
+  auto js_message = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_message);
   auto js_path = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
       rt, callInvoker, rs_path);
   auto js_uniffiFutureCallback = uniffi::breez_sdk_spark::Bridging<
@@ -5914,7 +6688,7 @@ static void body(jsi::Runtime &rt,
   try {
     // Getting the callback function
     auto cb = callbackValue->asObject(rt).asFunction(rt);
-    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_hash, js_path,
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_message, js_path,
                                 js_uniffiFutureCallback, js_uniffiCallbackData);
 
     // return type is MutReference(Struct("ForeignFuture"))
@@ -5924,14 +6698,14 @@ static void body(jsi::Runtime &rt,
             rt, callInvoker, uniffiResult);
   } catch (const jsi::JSError &error) {
     std::cout << "Error in callback "
-                 "UniffiCallbackInterfaceExternalBreezSignerMethod5: "
+                 "UniffiCallbackInterfaceExternalSigningSignerMethod2: "
               << error.what() << std::endl;
     throw error;
   }
 }
 
 static void
-callback(uint64_t rs_uniffiHandle, RustBuffer rs_hash, RustBuffer rs_path,
+callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
          UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
          uint64_t rs_uniffiCallbackData,
          UniffiForeignFuture *rs_uniffiOutReturn) {
@@ -5950,12 +6724,12 @@ callback(uint64_t rs_uniffiHandle, RustBuffer rs_hash, RustBuffer rs_path,
 
   // The runtime, the actual callback jsi::funtion, and the callInvoker
   // are all in the lambda.
-  rsLambda(rs_uniffiHandle, rs_hash, rs_path, rs_uniffiFutureCallback,
+  rsLambda(rs_uniffiHandle, rs_message, rs_path, rs_uniffiFutureCallback,
            rs_uniffiCallbackData, rs_uniffiOutReturn);
 }
 
-static UniffiCallbackInterfaceExternalBreezSignerMethod5
-makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod5
+static UniffiCallbackInterfaceExternalSigningSignerMethod2
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod2
     jsi::Runtime &rt,
     std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
     const jsi::Value &value) {
@@ -5974,7 +6748,7 @@ makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalb
   auto callbackFunction = value.asObject(rt).asFunction(rt);
   auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
   rsLambda = [&rt, callInvoker, callbackValue](
-                 uint64_t rs_uniffiHandle, RustBuffer rs_hash,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
                  RustBuffer rs_path,
                  UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
                  uint64_t rs_uniffiCallbackData,
@@ -5982,10 +6756,10 @@ makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalb
     // We immediately make a lambda which will do the work of transforming the
     // arguments into JSI values and calling the callback.
     uniffi_runtime::UniffiCallFunc jsLambda =
-        [callInvoker, callbackValue, rs_uniffiHandle, rs_hash, rs_path,
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_message, rs_path,
          rs_uniffiFutureCallback, rs_uniffiCallbackData,
          rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
-          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_hash,
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_message,
                rs_path, rs_uniffiFutureCallback, rs_uniffiCallbackData,
                rs_uniffiOutReturn);
         };
@@ -6004,12 +6778,12 @@ static void cleanup() {
   rsLambda = nullptr;
 }
 } // namespace
-  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod5
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod2
   // Implementation of callback function calling from Rust to JS
-  // CallbackInterfaceExternalBreezSignerMethod6
+  // CallbackInterfaceExternalSigningSignerMethod3
 
 // Callback function:
-// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod6::UniffiCallbackInterfaceExternalBreezSignerMethod6
+// uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod3::UniffiCallbackInterfaceExternalSigningSignerMethod3
 //
 // We have the following constraints:
 // - we need to pass a function pointer to Rust.
@@ -6023,7 +6797,7 @@ static void cleanup() {
 // We then give the `callback` function pointer to Rust which will call the
 // lambda sometime in the future.
 namespace uniffi::breez_sdk_spark::cb::
-    callbackinterfaceexternalbreezsignermethod6 {
+    callbackinterfaceexternalsigningsignermethod3 {
 using namespace facebook;
 
 // We need to store a lambda in a global so we can call it from
@@ -6038,7 +6812,7 @@ static std::function<void(uint64_t, RustBuffer, RustBuffer,
 static void body(jsi::Runtime &rt,
                  std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
                  std::shared_ptr<jsi::Value> callbackValue,
-                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_hash,
                  RustBuffer rs_path,
                  UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
                  uint64_t rs_uniffiCallbackData,
@@ -6048,8 +6822,8 @@ static void body(jsi::Runtime &rt,
   // We'll use the Bridging class to do this…
   auto js_uniffiHandle =
       uniffi_jsi::Bridging<uint64_t>::toJs(rt, callInvoker, rs_uniffiHandle);
-  auto js_message = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
-      rt, callInvoker, rs_message);
+  auto js_hash = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
+      rt, callInvoker, rs_hash);
   auto js_path = uniffi::breez_sdk_spark::Bridging<RustBuffer>::toJs(
       rt, callInvoker, rs_path);
   auto js_uniffiFutureCallback = uniffi::breez_sdk_spark::Bridging<
@@ -6064,7 +6838,7 @@ static void body(jsi::Runtime &rt,
   try {
     // Getting the callback function
     auto cb = callbackValue->asObject(rt).asFunction(rt);
-    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_message, js_path,
+    auto uniffiResult = cb.call(rt, js_uniffiHandle, js_hash, js_path,
                                 js_uniffiFutureCallback, js_uniffiCallbackData);
 
     // return type is MutReference(Struct("ForeignFuture"))
@@ -6074,14 +6848,14 @@ static void body(jsi::Runtime &rt,
             rt, callInvoker, uniffiResult);
   } catch (const jsi::JSError &error) {
     std::cout << "Error in callback "
-                 "UniffiCallbackInterfaceExternalBreezSignerMethod6: "
+                 "UniffiCallbackInterfaceExternalSigningSignerMethod3: "
               << error.what() << std::endl;
     throw error;
   }
 }
 
 static void
-callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
+callback(uint64_t rs_uniffiHandle, RustBuffer rs_hash, RustBuffer rs_path,
          UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
          uint64_t rs_uniffiCallbackData,
          UniffiForeignFuture *rs_uniffiOutReturn) {
@@ -6100,12 +6874,12 @@ callback(uint64_t rs_uniffiHandle, RustBuffer rs_message, RustBuffer rs_path,
 
   // The runtime, the actual callback jsi::funtion, and the callInvoker
   // are all in the lambda.
-  rsLambda(rs_uniffiHandle, rs_message, rs_path, rs_uniffiFutureCallback,
+  rsLambda(rs_uniffiHandle, rs_hash, rs_path, rs_uniffiFutureCallback,
            rs_uniffiCallbackData, rs_uniffiOutReturn);
 }
 
-static UniffiCallbackInterfaceExternalBreezSignerMethod6
-makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod6
+static UniffiCallbackInterfaceExternalSigningSignerMethod3
+makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod3
     jsi::Runtime &rt,
     std::shared_ptr<uniffi_runtime::UniffiCallInvoker> callInvoker,
     const jsi::Value &value) {
@@ -6124,7 +6898,7 @@ makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalb
   auto callbackFunction = value.asObject(rt).asFunction(rt);
   auto callbackValue = std::make_shared<jsi::Value>(rt, callbackFunction);
   rsLambda = [&rt, callInvoker, callbackValue](
-                 uint64_t rs_uniffiHandle, RustBuffer rs_message,
+                 uint64_t rs_uniffiHandle, RustBuffer rs_hash,
                  RustBuffer rs_path,
                  UniffiForeignFutureCompleteRustBuffer rs_uniffiFutureCallback,
                  uint64_t rs_uniffiCallbackData,
@@ -6132,10 +6906,10 @@ makeCallbackFunction( // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalb
     // We immediately make a lambda which will do the work of transforming the
     // arguments into JSI values and calling the callback.
     uniffi_runtime::UniffiCallFunc jsLambda =
-        [callInvoker, callbackValue, rs_uniffiHandle, rs_message, rs_path,
+        [callInvoker, callbackValue, rs_uniffiHandle, rs_hash, rs_path,
          rs_uniffiFutureCallback, rs_uniffiCallbackData,
          rs_uniffiOutReturn](jsi::Runtime &rt) mutable {
-          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_message,
+          body(rt, callInvoker, callbackValue, rs_uniffiHandle, rs_hash,
                rs_path, rs_uniffiFutureCallback, rs_uniffiCallbackData,
                rs_uniffiOutReturn);
         };
@@ -6154,7 +6928,7 @@ static void cleanup() {
   rsLambda = nullptr;
 }
 } // namespace
-  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod6
+  // uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod3
   // Implementation of callback function calling from Rust to JS
   // CallbackInterfaceExternalSparkSignerMethod0
 
@@ -14827,6 +15601,52 @@ namespace uniffi::breez_sdk_spark {
 using namespace facebook;
 using CallInvoker = uniffi_runtime::UniffiCallInvoker;
 
+template <>
+struct Bridging<UniffiVTableCallbackInterfaceExternalSigningSigner> {
+  static UniffiVTableCallbackInterfaceExternalSigningSigner
+  fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
+         const jsi::Value &jsValue) {
+    // Check if the input is an object
+    if (!jsValue.isObject()) {
+      throw jsi::JSError(rt,
+                         "Expected an object for "
+                         "UniffiVTableCallbackInterfaceExternalSigningSigner");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiVTableCallbackInterfaceExternalSigningSigner rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.derive_public_key = uniffi::breez_sdk_spark::cb::
+        callbackinterfaceexternalsigningsignermethod0::makeCallbackFunction(
+            rt, callInvoker, jsObject.getProperty(rt, "derivePublicKey"));
+    rsObject.sign_ecdsa = uniffi::breez_sdk_spark::cb::
+        callbackinterfaceexternalsigningsignermethod1::makeCallbackFunction(
+            rt, callInvoker, jsObject.getProperty(rt, "signEcdsa"));
+    rsObject.sign_ecdsa_recoverable = uniffi::breez_sdk_spark::cb::
+        callbackinterfaceexternalsigningsignermethod2::makeCallbackFunction(
+            rt, callInvoker, jsObject.getProperty(rt, "signEcdsaRecoverable"));
+    rsObject.sign_hash_schnorr = uniffi::breez_sdk_spark::cb::
+        callbackinterfaceexternalsigningsignermethod3::makeCallbackFunction(
+            rt, callInvoker, jsObject.getProperty(rt, "signHashSchnorr"));
+    rsObject.uniffi_free = uniffi::breez_sdk_spark::st::
+        vtablecallbackinterfaceexternalsigningsigner::
+            vtablecallbackinterfaceexternalsigningsigner::free::
+                makeCallbackFunction(rt, callInvoker,
+                                     jsObject.getProperty(rt, "uniffiFree"));
+
+    return rsObject;
+  }
+};
+
+} // namespace uniffi::breez_sdk_spark
+namespace uniffi::breez_sdk_spark {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
 template <> struct Bridging<UniffiVTableCallbackInterfaceExternalSparkSigner> {
   static UniffiVTableCallbackInterfaceExternalSparkSigner
   fromJs(jsi::Runtime &rt, std::shared_ptr<CallInvoker> callInvoker,
@@ -16131,6 +16951,91 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
             ->cpp_uniffi_breez_sdk_spark_fn_method_externalbreezsigner_hmac_sha256(
                 rt, thisVal, args, count);
       });
+  props["ubrn_uniffi_breez_sdk_spark_fn_clone_externalsigningsigner"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_breez_sdk_spark_fn_clone_externalsigningsigner"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_breez_sdk_spark_fn_clone_externalsigningsigner(
+                    rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_breez_sdk_spark_fn_free_externalsigningsigner"] =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(
+              rt, "ubrn_uniffi_breez_sdk_spark_fn_free_externalsigningsigner"),
+          1,
+          [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+            return this
+                ->cpp_uniffi_breez_sdk_spark_fn_free_externalsigningsigner(
+                    rt, thisVal, args, count);
+          });
+  props["ubrn_uniffi_breez_sdk_spark_fn_init_callback_vtable_"
+        "externalsigningsigner"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_fn_init_"
+                                    "callback_vtable_externalsigningsigner"),
+      1,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_fn_init_callback_vtable_externalsigningsigner(
+                rt, thisVal, args, count);
+      });
+  props["ubrn_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_derive_"
+        "public_key"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_fn_method_"
+                                    "externalsigningsigner_derive_public_key"),
+      2,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_derive_public_key(
+                rt, thisVal, args, count);
+      });
+  props["ubrn_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_"
+        "ecdsa"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_fn_method_"
+                                    "externalsigningsigner_sign_ecdsa"),
+      3,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_ecdsa(
+                rt, thisVal, args, count);
+      });
+  props["ubrn_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_"
+        "ecdsa_recoverable"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt,
+                                "ubrn_uniffi_breez_sdk_spark_fn_method_"
+                                "externalsigningsigner_sign_ecdsa_recoverable"),
+      3,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_ecdsa_recoverable(
+                rt, thisVal, args, count);
+      });
+  props["ubrn_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_hash_"
+        "schnorr"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_fn_method_"
+                                    "externalsigningsigner_sign_hash_schnorr"),
+      3,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_hash_schnorr(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_breez_sdk_spark_fn_clone_externalsparksigner"] =
       jsi::Function::createFromHostFunction(
           rt,
@@ -16840,6 +17745,19 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
             ->cpp_uniffi_breez_sdk_spark_fn_constructor_sdkbuilder_new_with_signer(
                 rt, thisVal, args, count);
       });
+  props["ubrn_uniffi_breez_sdk_spark_fn_constructor_sdkbuilder_new_with_"
+        "signing_only_signer"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt,
+                                "ubrn_uniffi_breez_sdk_spark_fn_constructor_"
+                                "sdkbuilder_new_with_signing_only_signer"),
+      3,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_fn_constructor_sdkbuilder_new_with_signing_only_signer(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_breez_sdk_spark_fn_method_sdkbuilder_build"] =
       jsi::Function::createFromHostFunction(
           rt,
@@ -17644,6 +18562,18 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
             return this->cpp_uniffi_breez_sdk_spark_fn_func_connect_with_signer(
                 rt, thisVal, args, count);
           });
+  props["ubrn_uniffi_breez_sdk_spark_fn_func_connect_with_signing_only_"
+        "signer"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_fn_func_"
+                                    "connect_with_signing_only_signer"),
+      1,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_fn_func_connect_with_signing_only_signer(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_breez_sdk_spark_fn_func_create_turnkey_signer"] =
       jsi::Function::createFromHostFunction(
           rt,
@@ -17656,6 +18586,18 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
                 ->cpp_uniffi_breez_sdk_spark_fn_func_create_turnkey_signer(
                     rt, thisVal, args, count);
           });
+  props["ubrn_uniffi_breez_sdk_spark_fn_func_create_turnkey_signing_only_"
+        "signer"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_fn_func_"
+                                    "create_turnkey_signing_only_signer"),
+      1,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_fn_func_create_turnkey_signing_only_signer(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_breez_sdk_spark_fn_func_custom_storage"] =
       jsi::Function::createFromHostFunction(
           rt,
@@ -18357,6 +19299,18 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
                 ->cpp_uniffi_breez_sdk_spark_checksum_func_connect_with_signer(
                     rt, thisVal, args, count);
           });
+  props["ubrn_uniffi_breez_sdk_spark_checksum_func_connect_with_signing_only_"
+        "signer"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_checksum_func_"
+                                    "connect_with_signing_only_signer"),
+      0,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_checksum_func_connect_with_signing_only_signer(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_breez_sdk_spark_checksum_func_create_turnkey_signer"] =
       jsi::Function::createFromHostFunction(
           rt,
@@ -18369,6 +19323,18 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
                 ->cpp_uniffi_breez_sdk_spark_checksum_func_create_turnkey_signer(
                     rt, thisVal, args, count);
           });
+  props["ubrn_uniffi_breez_sdk_spark_checksum_func_create_turnkey_signing_only_"
+        "signer"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_checksum_func_"
+                                    "create_turnkey_signing_only_signer"),
+      0,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_checksum_func_create_turnkey_signing_only_signer(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_breez_sdk_spark_checksum_func_custom_storage"] =
       jsi::Function::createFromHostFunction(
           rt,
@@ -19187,6 +20153,57 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
             ->cpp_uniffi_breez_sdk_spark_checksum_method_externalbreezsigner_hmac_sha256(
                 rt, thisVal, args, count);
       });
+  props["ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_"
+        "derive_public_key"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt,
+                                "ubrn_uniffi_breez_sdk_spark_checksum_method_"
+                                "externalsigningsigner_derive_public_key"),
+      0,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_derive_public_key(
+                rt, thisVal, args, count);
+      });
+  props["ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_"
+        "sign_ecdsa"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_breez_sdk_spark_checksum_"
+                                    "method_externalsigningsigner_sign_ecdsa"),
+      0,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_ecdsa(
+                rt, thisVal, args, count);
+      });
+  props["ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_"
+        "sign_ecdsa_recoverable"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt,
+                                "ubrn_uniffi_breez_sdk_spark_checksum_method_"
+                                "externalsigningsigner_sign_ecdsa_recoverable"),
+      0,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_ecdsa_recoverable(
+                rt, thisVal, args, count);
+      });
+  props["ubrn_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_"
+        "sign_hash_schnorr"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt,
+                                "ubrn_uniffi_breez_sdk_spark_checksum_method_"
+                                "externalsigningsigner_sign_hash_schnorr"),
+      0,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_hash_schnorr(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_get_"
         "identity_public_key"] = jsi::Function::createFromHostFunction(
       rt,
@@ -20255,6 +21272,19 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
             ->cpp_uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new_with_signer(
                 rt, thisVal, args, count);
       });
+  props["ubrn_uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new_with_"
+        "signing_only_signer"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(
+          rt, "ubrn_uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new_"
+              "with_signing_only_signer"),
+      0,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new_with_signing_only_signer(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_breez_sdk_spark_checksum_method_eventlistener_on_event"] =
       jsi::Function::createFromHostFunction(
           rt,
@@ -20325,6 +21355,18 @@ NativeBreezSdkSpark::NativeBreezSdkSpark(
             ->cpp_uniffi_internal_fn_method_externalbreezsigner_ffi__bless_pointer(
                 rt, thisVal, args, count);
       });
+  props["ubrn_uniffi_internal_fn_method_externalsigningsigner_ffi__bless_"
+        "pointer"] = jsi::Function::createFromHostFunction(
+      rt,
+      jsi::PropNameID::forAscii(rt, "ubrn_uniffi_internal_fn_method_"
+                                    "externalsigningsigner_ffi__bless_pointer"),
+      1,
+      [this](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+        return this
+            ->cpp_uniffi_internal_fn_method_externalsigningsigner_ffi__bless_pointer(
+                rt, thisVal, args, count);
+      });
   props["ubrn_uniffi_internal_fn_method_externalsparksigner_ffi__bless_"
         "pointer"] = jsi::Function::createFromHostFunction(
       rt,
@@ -20551,6 +21593,8 @@ NativeBreezSdkSpark::~NativeBreezSdkSpark() {
       vtablecallbackinterfacebitcoinchainservice::free::cleanup();
   uniffi::breez_sdk_spark::st::vtablecallbackinterfaceexternalbreezsigner::
       vtablecallbackinterfaceexternalbreezsigner::free::cleanup();
+  uniffi::breez_sdk_spark::st::vtablecallbackinterfaceexternalsigningsigner::
+      vtablecallbackinterfaceexternalsigningsigner::free::cleanup();
   uniffi::breez_sdk_spark::st::vtablecallbackinterfaceexternalsparksigner::
       vtablecallbackinterfaceexternalsparksigner::free::cleanup();
   uniffi::breez_sdk_spark::st::vtablecallbackinterfacefiatservice::
@@ -20607,6 +21651,18 @@ NativeBreezSdkSpark::~NativeBreezSdkSpark() {
   // Cleanup for callback function CallbackInterfaceExternalBreezSignerMethod6
   uniffi::breez_sdk_spark::cb::callbackinterfaceexternalbreezsignermethod6::
       cleanup();
+  // Cleanup for callback function CallbackInterfaceExternalSigningSignerMethod0
+  uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod0::
+      cleanup();
+  // Cleanup for callback function CallbackInterfaceExternalSigningSignerMethod1
+  uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod1::
+      cleanup();
+  // Cleanup for callback function CallbackInterfaceExternalSigningSignerMethod2
+  uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod2::
+      cleanup();
+  // Cleanup for callback function CallbackInterfaceExternalSigningSignerMethod3
+  uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsigningsignermethod3::
+      cleanup();
   // Cleanup for callback function CallbackInterfaceExternalSparkSignerMethod0
   uniffi::breez_sdk_spark::cb::callbackinterfaceexternalsparksignermethod0::
       cleanup();
@@ -20814,6 +21870,22 @@ jsi::Value NativeBreezSdkSpark::
   auto obj = jsi::Object::createFromHostObject(rt, ptrObj);
   return jsi::Value(rt, obj);
 }
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_internal_fn_method_externalsigningsigner_ffi__bless_pointer(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto pointer =
+      uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]);
+  auto static destructor = [](uint64_t p) {
+    auto pointer = reinterpret_cast<void *>(static_cast<uintptr_t>(p));
+    RustCallStatus status = {0};
+    uniffi_breez_sdk_spark_fn_free_externalsigningsigner(pointer, &status);
+  };
+  auto ptrObj =
+      std::make_shared<uniffi_jsi::DestructibleObject>(pointer, destructor);
+  auto obj = jsi::Object::createFromHostObject(rt, ptrObj);
+  return jsi::Value(rt, obj);
+}
 jsi::Value NativeBreezSdkSpark::
     cpp_uniffi_internal_fn_method_externalsparksigner_ffi__bless_pointer(
         jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
@@ -21853,6 +22925,107 @@ jsi::Value NativeBreezSdkSpark::
                                                          value);
 }
 jsi::Value
+NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_fn_clone_externalsigningsigner(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::breez_sdk_spark::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value = uniffi_breez_sdk_spark_fn_clone_externalsigningsigner(
+      uniffi_jsi::Bridging<void *>::fromJs(rt, callInvoker, args[0]), &status);
+  uniffi::breez_sdk_spark::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<void *>::toJs(rt, callInvoker, value);
+}
+jsi::Value
+NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_fn_free_externalsigningsigner(
+    jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+    size_t count) {
+  RustCallStatus status =
+      uniffi::breez_sdk_spark::Bridging<RustCallStatus>::rustSuccess(rt);
+  uniffi_breez_sdk_spark_fn_free_externalsigningsigner(
+      uniffi_jsi::Bridging<void *>::fromJs(rt, callInvoker, args[0]), &status);
+  uniffi::breez_sdk_spark::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return jsi::Value::undefined();
+}
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_fn_init_callback_vtable_externalsigningsigner(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto vtableInstance = uniffi::breez_sdk_spark::Bridging<
+      UniffiVTableCallbackInterfaceExternalSigningSigner>::fromJs(rt,
+                                                                  callInvoker,
+                                                                  args[0]);
+
+  std::lock_guard<std::mutex> lock(
+      uniffi::breez_sdk_spark::registry::vtableMutex);
+  uniffi_breez_sdk_spark_fn_init_callback_vtable_externalsigningsigner(
+      uniffi::breez_sdk_spark::registry::putTable(
+          "UniffiVTableCallbackInterfaceExternalSigningSigner",
+          vtableInstance));
+  return jsi::Value::undefined();
+}
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_derive_public_key(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_fn_method_externalsigningsigner_derive_public_key(
+          uniffi_jsi::Bridging<void *>::fromJs(rt, callInvoker, args[0]),
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[1]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_ecdsa(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_ecdsa(
+          uniffi_jsi::Bridging<void *>::fromJs(rt, callInvoker, args[0]),
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[1]),
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[2]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_ecdsa_recoverable(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_ecdsa_recoverable(
+          uniffi_jsi::Bridging<void *>::fromJs(rt, callInvoker, args[0]),
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[1]),
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[2]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_hash_schnorr(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_fn_method_externalsigningsigner_sign_hash_schnorr(
+          uniffi_jsi::Bridging<void *>::fromJs(rt, callInvoker, args[0]),
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[1]),
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[2]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
+jsi::Value
 NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_fn_clone_externalsparksigner(
     jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
     size_t count) {
@@ -22614,6 +23787,24 @@ jsi::Value NativeBreezSdkSpark::
 
   return uniffi_jsi::Bridging<void *>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_fn_constructor_sdkbuilder_new_with_signing_only_signer(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  RustCallStatus status =
+      uniffi::breez_sdk_spark::Bridging<RustCallStatus>::rustSuccess(rt);
+  auto value =
+      uniffi_breez_sdk_spark_fn_constructor_sdkbuilder_new_with_signing_only_signer(
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[0]),
+          uniffi_jsi::Bridging<void *>::fromJs(rt, callInvoker, args[1]),
+          uniffi_jsi::Bridging<void *>::fromJs(rt, callInvoker, args[2]),
+          &status);
+  uniffi::breez_sdk_spark::Bridging<RustCallStatus>::copyIntoJs(
+      rt, callInvoker, status, args[count - 1]);
+
+  return uniffi_jsi::Bridging<void *>::toJs(rt, callInvoker, value);
+}
 jsi::Value
 NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_fn_method_sdkbuilder_build(
     jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
@@ -23438,6 +24629,17 @@ NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_fn_func_connect_with_signer(
   return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
                                                          value);
 }
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_fn_func_connect_with_signing_only_signer(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value = uniffi_breez_sdk_spark_fn_func_connect_with_signing_only_signer(
+      uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                            args[0]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
 jsi::Value
 NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_fn_func_create_turnkey_signer(
     jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
@@ -23449,6 +24651,18 @@ NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_fn_func_create_turnkey_signer(
   return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
                                                          value);
 }
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_fn_func_create_turnkey_signing_only_signer(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_fn_func_create_turnkey_signing_only_signer(
+          uniffi::breez_sdk_spark::Bridging<RustBuffer>::fromJs(rt, callInvoker,
+                                                                args[0]));
+
+  return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker,
+                                                         value);
+}
 jsi::Value
 NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_fn_func_custom_storage(
     jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
@@ -24218,6 +25432,15 @@ jsi::Value NativeBreezSdkSpark::
 
   return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_checksum_func_connect_with_signing_only_signer(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_checksum_func_connect_with_signing_only_signer();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
 jsi::Value NativeBreezSdkSpark::
     cpp_uniffi_breez_sdk_spark_checksum_func_create_turnkey_signer(
         jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
@@ -24226,6 +25449,15 @@ jsi::Value NativeBreezSdkSpark::
 
   return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_checksum_func_create_turnkey_signing_only_signer(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_checksum_func_create_turnkey_signing_only_signer();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
 jsi::Value
 NativeBreezSdkSpark::cpp_uniffi_breez_sdk_spark_checksum_func_custom_storage(
     jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
@@ -24800,6 +26032,42 @@ jsi::Value NativeBreezSdkSpark::
 
   return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_derive_public_key(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_derive_public_key();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_ecdsa(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_ecdsa();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_ecdsa_recoverable(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_ecdsa_recoverable();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_hash_schnorr(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_checksum_method_externalsigningsigner_sign_hash_schnorr();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
 jsi::Value NativeBreezSdkSpark::
     cpp_uniffi_breez_sdk_spark_checksum_method_externalsparksigner_get_identity_public_key(
         jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
@@ -25561,6 +26829,15 @@ jsi::Value NativeBreezSdkSpark::
 
   return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeBreezSdkSpark::
+    cpp_uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new_with_signing_only_signer(
+        jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+        size_t count) {
+  auto value =
+      uniffi_breez_sdk_spark_checksum_constructor_sdkbuilder_new_with_signing_only_signer();
+
+  return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
 jsi::Value NativeBreezSdkSpark::
     cpp_uniffi_breez_sdk_spark_checksum_method_eventlistener_on_event(
         jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,