@secondts/bark-react-native 0.4.2 → 0.5.0

package/README.md

@@ -60,7 +60,7 @@ npx expo install @secondts/bark-react-native@beta
 
 ```bash
 # Or install a specific beta version
-npx expo install @secondts/bark-react-native@0.4.2
+npx expo install @secondts/bark-react-native@0.5.0
 ```
 
 For bare React Native projects, use:

package/cpp/generated/bark.cpp

@@ -130,6 +130,14 @@ extern "C" {
     UniffiForeignFutureResultVoid result
     );
     typedef void
+    (*UniffiCallbackInterfaceBarkLoggerMethod0)(
+    uint64_t uniffi_handle, 
+    RustBuffer level, 
+    RustBuffer target, 
+    RustBuffer message, 
+    void * uniffi_out_return, RustCallStatus* rust_call_status
+    );
+    typedef void
     (*UniffiCallbackInterfaceCustomOnchainWalletCallbacksMethod0)(
     uint64_t uniffi_handle, 
     uint64_t * uniffi_out_return, RustCallStatus* rust_call_status
@@ -183,7 +191,11 @@ extern "C" {
     uint64_t uniffi_handle, 
     RustBuffer tx_hex, 
     void * uniffi_out_return, RustCallStatus* rust_call_status
-    );typedef struct UniffiVTableCallbackInterfaceCustomOnchainWalletCallbacks {
+    );typedef struct UniffiVTableCallbackInterfaceBarkLogger {
+        UniffiCallbackInterfaceFree uniffi_free;
+        UniffiCallbackInterfaceClone uniffi_clone;
+        UniffiCallbackInterfaceBarkLoggerMethod0 log;
+    } UniffiVTableCallbackInterfaceBarkLogger;typedef struct UniffiVTableCallbackInterfaceCustomOnchainWalletCallbacks {
         UniffiCallbackInterfaceFree uniffi_free;
         UniffiCallbackInterfaceClone uniffi_clone;
         UniffiCallbackInterfaceCustomOnchainWalletCallbacksMethod0 get_balance;
@@ -304,7 +316,8 @@ extern "C" {
     );
     /*handle*/ uint64_t uniffi_bark_ffi_fn_method_wallet_bolt11_invoice(
         /*handle*/ uint64_t ptr, 
-        uint64_t amount_sats
+        uint64_t amount_sats, 
+        RustBuffer description
     );
     /*handle*/ uint64_t uniffi_bark_ffi_fn_method_wallet_broadcast_tx(
         /*handle*/ uint64_t ptr, 
@@ -604,6 +617,9 @@ extern "C" {
     /*handle*/ uint64_t uniffi_bark_ffi_fn_method_wallet_vtxos(
         /*handle*/ uint64_t ptr
     );
+    void uniffi_bark_ffi_fn_init_callback_vtable_barklogger(
+        UniffiVTableCallbackInterfaceBarkLogger * vtable
+    );
     void uniffi_bark_ffi_fn_init_callback_vtable_customonchainwalletcallbacks(
         UniffiVTableCallbackInterfaceCustomOnchainWalletCallbacks * vtable
     );
@@ -613,6 +629,11 @@ extern "C" {
     );
     RustBuffer uniffi_bark_ffi_fn_func_generate_mnemonic(RustCallStatus *uniffi_out_err
     );
+    void uniffi_bark_ffi_fn_func_set_logger(
+        uint64_t logger, 
+        RustBuffer max_level, 
+        RustCallStatus *uniffi_out_err
+    );
     int8_t uniffi_bark_ffi_fn_func_validate_ark_address(
         RustBuffer address, 
         RustCallStatus *uniffi_out_err
@@ -822,6 +843,8 @@ extern "C" {
     );
     uint16_t uniffi_bark_ffi_checksum_func_generate_mnemonic(
     );
+    uint16_t uniffi_bark_ffi_checksum_func_set_logger(
+    );
     uint16_t uniffi_bark_ffi_checksum_func_validate_ark_address(
     );
     uint16_t uniffi_bark_ffi_checksum_func_validate_mnemonic(
@@ -1024,6 +1047,8 @@ extern "C" {
     );
     uint16_t uniffi_bark_ffi_checksum_constructor_wallet_open_with_onchain(
     );
+    uint16_t uniffi_bark_ffi_checksum_method_barklogger_log(
+    );
     uint16_t uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_balance(
     );
     uint16_t uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_tx(
@@ -1502,6 +1527,121 @@ namespace uniffi::bark::cb::foreignfuturedroppedcallback {
     // Implementation of free callback function CallbackInterfaceFree
 
 
+// Callback function: uniffi::bark::st::vtablecallbackinterfacebarklogger::vtablecallbackinterfacebarklogger::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::bark::st::vtablecallbackinterfacebarklogger::vtablecallbackinterfacebarklogger::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);
+    }
+
+    [[maybe_unused]] static UniffiCallbackInterfaceFree
+    makeCallbackFunction( // uniffi::bark::st::vtablecallbackinterfacebarklogger::vtablecallbackinterfacebarklogger::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 NativeBark, 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::bark::st::vtablecallbackinterfacebarklogger::vtablecallbackinterfacebarklogger::free
+
 // Callback function: uniffi::bark::st::vtablecallbackinterfacecustomonchainwalletcallbacks::vtablecallbackinterfacecustomonchainwalletcallbacks::free::UniffiCallbackInterfaceFree
 //
 // We have the following constraints:
@@ -2533,6 +2673,309 @@ template <> struct Bridging<UniffiForeignFutureCompleteVoid> {
         return jsi::Value::undefined();
   }
 };
+} // namespace uniffi::bark
+    // Implementation of CallbackInterfaceClone for vtable field uniffi_clone in VTableCallbackInterfaceBarkLogger
+
+
+// Callback function: uniffi::bark::cb::callbackinterfaceclone::vtablecallbackinterfacebarklogger::UniffiCallbackInterfaceClone
+//
+// 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::bark::cb::callbackinterfaceclone::vtablecallbackinterfacebarklogger {
+    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, 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
+            , uint64_t* uniffi_direct_return) {
+
+        // 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
+            );
+
+            
+
+            
+            // Write the direct return value back to the caller.
+            if (uniffi_direct_return != nullptr) {
+                *uniffi_direct_return = uniffi_jsi::Bridging<uint64_t>::fromJs(
+                    rt, callInvoker, uniffiResult
+                );
+            }
+        } catch (const jsi::JSError &error) {
+            std::cout << "Error in callback UniffiCallbackInterfaceClone: "
+                    << error.what() << std::endl;
+            throw error;
+        }
+    }
+
+    static uint64_t 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 0;
+        }
+        uint64_t uniffi_result = 0;
+
+        // The runtime, the actual callback jsi::funtion, and the callInvoker
+        // are all in the lambda.
+        rsLambda(
+            rs_handle, 
+            &uniffi_result);
+        return uniffi_result;
+    }
+
+    [[maybe_unused]] static UniffiCallbackInterfaceClone
+    makeCallbackFunction( // uniffi::bark::cb::callbackinterfaceclone::vtablecallbackinterfacebarklogger
+                    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, uint64_t* uniffi_direct_return) {
+                // 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, uniffi_direct_return](jsi::Runtime &rt) mutable {
+                    body(rt, callInvoker, callbackValue
+                        , rs_handle, uniffi_direct_return);
+                };
+                // 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 NativeBark, 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::bark::cb::callbackinterfaceclone::vtablecallbackinterfacebarklogger
+    // Implementation of CallbackInterfaceBarkLoggerMethod0 for vtable field log in VTableCallbackInterfaceBarkLogger
+
+
+// Callback function: uniffi::bark::cb::callbackinterfacebarkloggermethod0::vtablecallbackinterfacebarklogger::UniffiCallbackInterfaceBarkLoggerMethod0
+//
+// 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::bark::cb::callbackinterfacebarkloggermethod0::vtablecallbackinterfacebarklogger {
+    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, RustBuffer, void *, RustCallStatus*)> 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_level
+            ,RustBuffer rs_target
+            ,RustBuffer rs_message
+            ,void * rs_uniffiOutReturn, RustCallStatus* uniffi_call_status) {
+
+        // 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_level = uniffi::bark::Bridging<RustBuffer>::toJs(rt, callInvoker, rs_level);
+        auto js_target = uniffi::bark::Bridging<RustBuffer>::toJs(rt, callInvoker, rs_target);
+        auto js_message = uniffi::bark::Bridging<RustBuffer>::toJs(rt, callInvoker, rs_message);
+
+        // 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_level, js_target, js_message
+            );
+
+            // Now copy the result back from JS into the RustCallStatus object.
+            uniffi::bark::Bridging<RustCallStatus>::copyFromJs(rt, callInvoker, uniffiResult, uniffi_call_status);
+
+            if (uniffi_call_status->code != UNIFFI_CALL_STATUS_OK) {
+                // The JS callback finished abnormally, so we cannot retrieve the return value.
+                return;
+            }
+
+            
+        } catch (const jsi::JSError &error) {
+            std::cout << "Error in callback UniffiCallbackInterfaceBarkLoggerMethod0: "
+                    << error.what() << std::endl;
+            throw error;
+        }
+    }
+
+    static void callback(uint64_t rs_uniffiHandle, RustBuffer rs_level, RustBuffer rs_target, RustBuffer rs_message, void * rs_uniffiOutReturn, RustCallStatus* uniffi_call_status) {
+        // 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_level, 
+            rs_target, 
+            rs_message, 
+            rs_uniffiOutReturn, uniffi_call_status);
+    }
+
+    [[maybe_unused]] static UniffiCallbackInterfaceBarkLoggerMethod0
+    makeCallbackFunction( // uniffi::bark::cb::callbackinterfacebarkloggermethod0::vtablecallbackinterfacebarklogger
+                    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_level, RustBuffer rs_target, RustBuffer rs_message, void * rs_uniffiOutReturn, RustCallStatus* uniffi_call_status) {
+                // 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_level
+                    , rs_target
+                    , rs_message
+                    , rs_uniffiOutReturn, uniffi_call_status](jsi::Runtime &rt) mutable {
+                    body(rt, callInvoker, callbackValue
+                        , rs_uniffiHandle
+                        , rs_level
+                        , rs_target
+                        , rs_message
+                        , rs_uniffiOutReturn, uniffi_call_status);
+                };
+                // 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 NativeBark, 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::bark::cb::callbackinterfacebarkloggermethod0::vtablecallbackinterfacebarklogger
+namespace uniffi::bark {
+using namespace facebook;
+using CallInvoker = uniffi_runtime::UniffiCallInvoker;
+
+template <> struct Bridging<UniffiVTableCallbackInterfaceBarkLogger> {
+  static UniffiVTableCallbackInterfaceBarkLogger 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 UniffiVTableCallbackInterfaceBarkLogger");
+    }
+
+    // Get the object from the jsi::Value
+    auto jsObject = jsValue.getObject(rt);
+
+    // Create the vtable struct
+    UniffiVTableCallbackInterfaceBarkLogger rsObject;
+
+    // Create the vtable from the js callbacks.
+    rsObject.uniffi_free = uniffi::bark::st::vtablecallbackinterfacebarklogger::vtablecallbackinterfacebarklogger::free::makeCallbackFunction(
+          rt, callInvoker, jsObject.getProperty(rt, "uniffiFree")
+        );
+    rsObject.uniffi_clone = uniffi::bark::cb::callbackinterfaceclone::vtablecallbackinterfacebarklogger::makeCallbackFunction(
+          rt, callInvoker, jsObject.getProperty(rt, "uniffiClone")
+        );
+    rsObject.log = uniffi::bark::cb::callbackinterfacebarkloggermethod0::vtablecallbackinterfacebarklogger::makeCallbackFunction(
+          rt, callInvoker, jsObject.getProperty(rt, "log")
+        );
+
+    return rsObject;
+  }
+};
+
 } // namespace uniffi::bark
     // Implementation of CallbackInterfaceClone for vtable field uniffi_clone in VTableCallbackInterfaceCustomOnchainWalletCallbacks
 
@@ -4226,7 +4669,7 @@ NativeBark::NativeBark(
     props["ubrn_uniffi_bark_ffi_fn_method_wallet_bolt11_invoice"] = jsi::Function::createFromHostFunction(
         rt,
         jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_fn_method_wallet_bolt11_invoice"),
-        2,
+        3,
         [this](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
             return this->cpp_uniffi_bark_ffi_fn_method_wallet_bolt11_invoice(rt, thisVal, args, count);
         }
@@ -4863,6 +5306,14 @@ NativeBark::NativeBark(
             return this->cpp_uniffi_bark_ffi_fn_method_wallet_vtxos(rt, thisVal, args, count);
         }
     );
+    props["ubrn_uniffi_bark_ffi_fn_init_callback_vtable_barklogger"] = jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_fn_init_callback_vtable_barklogger"),
+        1,
+        [this](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_bark_ffi_fn_init_callback_vtable_barklogger(rt, thisVal, args, count);
+        }
+    );
     props["ubrn_uniffi_bark_ffi_fn_init_callback_vtable_customonchainwalletcallbacks"] = jsi::Function::createFromHostFunction(
         rt,
         jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_fn_init_callback_vtable_customonchainwalletcallbacks"),
@@ -4887,6 +5338,14 @@ NativeBark::NativeBark(
             return this->cpp_uniffi_bark_ffi_fn_func_generate_mnemonic(rt, thisVal, args, count);
         }
     );
+    props["ubrn_uniffi_bark_ffi_fn_func_set_logger"] = jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_fn_func_set_logger"),
+        2,
+        [this](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_bark_ffi_fn_func_set_logger(rt, thisVal, args, count);
+        }
+    );
     props["ubrn_uniffi_bark_ffi_fn_func_validate_ark_address"] = jsi::Function::createFromHostFunction(
         rt,
         jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_fn_func_validate_ark_address"),
@@ -5303,6 +5762,14 @@ NativeBark::NativeBark(
             return this->cpp_uniffi_bark_ffi_checksum_func_generate_mnemonic(rt, thisVal, args, count);
         }
     );
+    props["ubrn_uniffi_bark_ffi_checksum_func_set_logger"] = jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_checksum_func_set_logger"),
+        0,
+        [this](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_bark_ffi_checksum_func_set_logger(rt, thisVal, args, count);
+        }
+    );
     props["ubrn_uniffi_bark_ffi_checksum_func_validate_ark_address"] = jsi::Function::createFromHostFunction(
         rt,
         jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_checksum_func_validate_ark_address"),
@@ -6111,6 +6578,14 @@ NativeBark::NativeBark(
             return this->cpp_uniffi_bark_ffi_checksum_constructor_wallet_open_with_onchain(rt, thisVal, args, count);
         }
     );
+    props["ubrn_uniffi_bark_ffi_checksum_method_barklogger_log"] = jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_checksum_method_barklogger_log"),
+        0,
+        [this](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+            return this->cpp_uniffi_bark_ffi_checksum_method_barklogger_log(rt, thisVal, args, count);
+        }
+    );
     props["ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_balance"] = jsi::Function::createFromHostFunction(
         rt,
         jsi::PropNameID::forAscii(rt, "ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_balance"),
@@ -6255,7 +6730,9 @@ uniffi::bark::cb::rustfuturecontinuationcallback::cleanup();
     // Cleanup for callback function ForeignFutureDroppedCallback
 uniffi::bark::cb::foreignfuturedroppedcallback::cleanup();
     // Cleanup for "free" callback function CallbackInterfaceFree
-uniffi::bark::st::vtablecallbackinterfacecustomonchainwalletcallbacks::vtablecallbackinterfacecustomonchainwalletcallbacks::free::cleanup();
+uniffi::bark::st::vtablecallbackinterfacebarklogger::vtablecallbackinterfacebarklogger::free::cleanup();uniffi::bark::st::vtablecallbackinterfacecustomonchainwalletcallbacks::vtablecallbackinterfacecustomonchainwalletcallbacks::free::cleanup();
+uniffi::bark::cb::callbackinterfaceclone::vtablecallbackinterfacebarklogger::cleanup();
+uniffi::bark::cb::callbackinterfacebarkloggermethod0::vtablecallbackinterfacebarklogger::cleanup();
 uniffi::bark::cb::callbackinterfaceclone::vtablecallbackinterfacecustomonchainwalletcallbacks::cleanup();
 uniffi::bark::cb::callbackinterfacecustomonchainwalletcallbacksmethod0::vtablecallbackinterfacecustomonchainwalletcallbacks::cleanup();
 uniffi::bark::cb::callbackinterfacecustomonchainwalletcallbacksmethod1::vtablecallbackinterfacecustomonchainwalletcallbacks::cleanup();
@@ -6509,7 +6986,7 @@ jsi::Value NativeBark::cpp_uniffi_bark_ffi_fn_method_wallet_board_amount(jsi::Ru
         return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker, value);
 }
 jsi::Value NativeBark::cpp_uniffi_bark_ffi_fn_method_wallet_bolt11_invoice(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
-        auto value = uniffi_bark_ffi_fn_method_wallet_bolt11_invoice(uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker, args[0]), uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[1])
+        auto value = uniffi_bark_ffi_fn_method_wallet_bolt11_invoice(uniffi_jsi::Bridging</*handle*/ uint64_t>::fromJs(rt, callInvoker, args[0]), uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[1]), uniffi::bark::Bridging<RustBuffer>::fromJs(rt, callInvoker, args[2])
         );
 
         
@@ -7080,6 +7557,23 @@ jsi::Value NativeBark::cpp_uniffi_bark_ffi_fn_method_wallet_vtxos(jsi::Runtime&
         
         return uniffi_jsi::Bridging</*handle*/ uint64_t>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeBark::cpp_uniffi_bark_ffi_fn_init_callback_vtable_barklogger(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
+    auto vtableInstance =
+        uniffi::bark::Bridging<UniffiVTableCallbackInterfaceBarkLogger>::fromJs(
+            rt,
+            callInvoker,
+            args[0]
+        );
+
+    std::lock_guard<std::mutex> lock(uniffi::bark::registry::vtableMutex);
+    uniffi_bark_ffi_fn_init_callback_vtable_barklogger(
+        uniffi::bark::registry::putTable(
+            "UniffiVTableCallbackInterfaceBarkLogger",
+            vtableInstance
+        )
+    );
+    return jsi::Value::undefined();
+}
 jsi::Value NativeBark::cpp_uniffi_bark_ffi_fn_init_callback_vtable_customonchainwalletcallbacks(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
     auto vtableInstance =
         uniffi::bark::Bridging<UniffiVTableCallbackInterfaceCustomOnchainWalletCallbacks>::fromJs(
@@ -7116,6 +7610,16 @@ jsi::Value NativeBark::cpp_uniffi_bark_ffi_fn_func_generate_mnemonic(jsi::Runtim
         
         return uniffi::bark::Bridging<RustBuffer>::toJs(rt, callInvoker, value);
 }
+jsi::Value NativeBark::cpp_uniffi_bark_ffi_fn_func_set_logger(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
+        RustCallStatus status = uniffi::bark::Bridging<RustCallStatus>::rustSuccess(rt);
+        uniffi_bark_ffi_fn_func_set_logger(uniffi_jsi::Bridging<uint64_t>::fromJs(rt, callInvoker, args[0]), uniffi::bark::Bridging<RustBuffer>::fromJs(rt, callInvoker, args[1]), 
+            &status
+        );
+        uniffi::bark::Bridging<RustCallStatus>::copyIntoJs(rt, callInvoker, status, args[count - 1]);
+
+        
+        return jsi::Value::undefined();
+}
 jsi::Value NativeBark::cpp_uniffi_bark_ffi_fn_func_validate_ark_address(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
         RustCallStatus status = uniffi::bark::Bridging<RustCallStatus>::rustSuccess(rt);
         auto value = uniffi_bark_ffi_fn_func_validate_ark_address(uniffi::bark::Bridging<RustBuffer>::fromJs(rt, callInvoker, args[0]), 
@@ -7520,6 +8024,13 @@ jsi::Value NativeBark::cpp_uniffi_bark_ffi_checksum_func_generate_mnemonic(jsi::
         );
 
         
+        return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeBark::cpp_uniffi_bark_ffi_checksum_func_set_logger(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
+        auto value = uniffi_bark_ffi_checksum_func_set_logger(
+        );
+
+        
         return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
 }
 jsi::Value NativeBark::cpp_uniffi_bark_ffi_checksum_func_validate_ark_address(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
@@ -8227,6 +8738,13 @@ jsi::Value NativeBark::cpp_uniffi_bark_ffi_checksum_constructor_wallet_open_with
         );
 
         
+        return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
+}
+jsi::Value NativeBark::cpp_uniffi_bark_ffi_checksum_method_barklogger_log(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
+        auto value = uniffi_bark_ffi_checksum_method_barklogger_log(
+        );
+
+        
         return uniffi_jsi::Bridging<uint16_t>::toJs(rt, callInvoker, value);
 }
 jsi::Value NativeBark::cpp_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_balance(jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {