@openwallet-foundation/askar-react-native 0.2.5

package/cpp/turboModuleUtility.cpp

@@ -0,0 +1,598 @@
+#include <vector>
+
+#include "turboModuleUtility.h"
+
+namespace askarTurboModuleUtility {
+
+using byteVector = std::vector<uint8_t>;
+
+std::shared_ptr<react::CallInvoker> invoker;
+
+void registerTurboModule(jsi::Runtime &rt,
+                         std::shared_ptr<react::CallInvoker> jsCallInvoker) {
+  // Setting the callInvoker for async code
+  invoker = jsCallInvoker;
+  // Create a TurboModuleRustHostObject
+  auto instance = std::make_shared<AskarTurboModuleHostObject>(rt);
+  // Create a JS equivalent object of the instance
+  jsi::Object jsInstance = jsi::Object::createFromHostObject(rt, instance);
+  // Register the object on global
+  rt.global().setProperty(rt, "_askar", std::move(jsInstance));
+}
+
+void assertValueIsObject(jsi::Runtime &rt, const jsi::Value *val) {
+  val->asObject(rt);
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             const char **value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto isNullptr = value == nullptr || *value == nullptr;
+    auto valueWithoutNullptr = isNullptr
+                                   ? jsi::Value::null()
+                                   : jsi::String::createFromAscii(rt, *value);
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             const char *const *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto isNullptr = value == nullptr || *value == nullptr;
+    auto valueWithoutNullptr = isNullptr
+                                   ? jsi::Value::null()
+                                   : jsi::String::createFromAscii(rt, *value);
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             nullptr_t value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    object.setProperty(rt, "value", jsi::Value::null());
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code, int8_t *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto valueWithoutNullptr =
+        value == nullptr ? jsi::Value::null() : jsi::Value(rt, int(*value));
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             int8_t const *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto valueWithoutNullptr =
+        value == nullptr ? jsi::Value::null() : jsi::Value(rt, int(*value));
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code, int32_t *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto valueWithoutNullptr =
+        value == nullptr ? jsi::Value::null() : jsi::Value(rt, int(*value));
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code, int64_t *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto valueWithoutNullptr =
+        value == nullptr ? jsi::Value::null() : jsi::Value(rt, int(*value));
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             int64_t const *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto valueWithoutNullptr =
+        value == nullptr ? jsi::Value::null() : jsi::Value(rt, int(*value));
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             size_t const *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto valueWithoutNullptr =
+        value == nullptr ? jsi::Value::null() : jsi::Value(rt, int(*value));
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             std::string value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    object.setProperty(rt, "value", jsi::String::createFromAscii(rt, value));
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             SecretBuffer *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    auto valueWithoutNullptr = value == nullptr
+                                   ? jsi::Value::null()
+                                   : secretBufferToArrayBuffer(rt, *value);
+    object.setProperty(rt, "value", valueWithoutNullptr);
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             LocalKeyHandle *value) {
+  auto isNullptr = value == nullptr || value->_0 == nullptr;
+  return isNullptr
+             ? createReturnValue(rt, code, nullptr)
+             : createReturnValue(rt, code, std::to_string(int64_t(intptr_t(value->_0))));
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             EntryListHandle const *value) {
+  auto isNullptr = value == nullptr || value->_0 == nullptr;
+  return isNullptr
+             ? createReturnValue(rt, code, nullptr)
+             : createReturnValue(rt, code, std::to_string(int64_t(intptr_t(value->_0))));
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             KeyEntryListHandle const *value) {
+  auto isNullptr = value == nullptr || value->_0 == nullptr;
+  return isNullptr
+             ? createReturnValue(rt, code, nullptr)
+             : createReturnValue(rt, code, std::to_string(int64_t(intptr_t(value->_0))));
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             StringListHandle const *value) {
+  auto isNullptr = value == nullptr || value->_0 == nullptr;
+  return isNullptr
+             ? createReturnValue(rt, code, nullptr)
+             : createReturnValue(rt, code, std::to_string(int64_t(intptr_t(value->_0))));
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             EncryptedBuffer *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    if (value == nullptr) {
+      object.setProperty(rt, "value", jsi::Value::null());
+    } else {
+      auto valueObject = jsi::Object(rt);
+
+      valueObject.setProperty(rt, "buffer",
+                              secretBufferToArrayBuffer(rt, value->buffer));
+      valueObject.setProperty(rt, "tagPos", int(value->tag_pos));
+      valueObject.setProperty(rt, "noncePos", int(value->nonce_pos));
+
+      object.setProperty(rt, "value", valueObject);
+    }
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+template <>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code,
+                             AeadParams *value) {
+  auto object = jsi::Object(rt);
+
+  if (code == ErrorCode::Success) {
+    if (value == nullptr) {
+      object.setProperty(rt, "value", jsi::Value::null());
+    } else {
+      auto valueObject = jsi::Object(rt);
+
+      valueObject.setProperty(rt, "nonceLength", int(value->nonce_length));
+      valueObject.setProperty(rt, "tagLength", int(value->tag_length));
+
+      object.setProperty(rt, "value", object);
+    }
+  }
+
+  object.setProperty(rt, "errorCode", int(code));
+
+  return object;
+}
+
+void callback(CallbackId result, ErrorCode code) {
+  invoker->invokeAsync([result, code]() {
+    State *_state = reinterpret_cast<State *>(result);
+    State *state = static_cast<State *>(_state);
+    jsi::Function *cb = &state->cb;
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime *>(state->rt);
+
+    auto object = jsi::Object(*rt);
+    object.setProperty(*rt, "errorCode", int(code));
+    cb->call(*rt, object);
+  });
+  //  delete state;
+}
+
+// Session, Store and Scan Handle
+template <>
+void callbackWithResponse(CallbackId result, ErrorCode code, size_t response) {
+  invoker->invokeAsync([result, code, response]() {
+    State *_state = reinterpret_cast<State *>(result);
+    State *state = static_cast<State *>(_state);
+    jsi::Function *cb = &state->cb;
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime *>(state->rt);
+
+    auto out = createReturnValue(*rt, code, &response);
+    cb->call(*rt, out);
+  });
+}
+
+template <>
+void callbackWithResponse(CallbackId result, ErrorCode code,
+                          const char *response) {
+  invoker->invokeAsync([result, code, response]() {
+    State *_state = reinterpret_cast<State *>(result);
+    State *state = static_cast<State *>(_state);
+    jsi::Function *cb = &state->cb;
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime *>(state->rt);
+
+    auto out = createReturnValue(*rt, code, &response);
+    cb->call(*rt, out);
+  });
+}
+
+template <>
+void callbackWithResponse(CallbackId result, ErrorCode code,
+                          EntryListHandle response) {
+  invoker->invokeAsync([result, code, response]() {
+    State *_state = reinterpret_cast<State *>(result);
+    State *state = static_cast<State *>(_state);
+    jsi::Function *cb = &state->cb;
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime *>(state->rt);
+
+    auto out = createReturnValue(*rt, code, &response);
+    cb->call(*rt, out);
+  });
+}
+
+template <>
+void callbackWithResponse(CallbackId result, ErrorCode code,
+                          KeyEntryListHandle response) {
+  invoker->invokeAsync([result, code, response]() {
+    State *_state = reinterpret_cast<State *>(result);
+    State *state = static_cast<State *>(_state);
+    jsi::Function *cb = &state->cb;
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime *>(state->rt);
+
+    auto out = createReturnValue(*rt, code, &response);
+    cb->call(*rt, out);
+  });
+}
+
+template <>
+void callbackWithResponse(CallbackId result, ErrorCode code,
+                          StringListHandle response) {
+  invoker->invokeAsync([result, code, response]() {
+    State *_state = reinterpret_cast<State *>(result);
+    State *state = static_cast<State *>(_state);
+    jsi::Function *cb = &state->cb;
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime *>(state->rt);
+
+    auto out = createReturnValue(*rt, code, &response);
+    cb->call(*rt, out);
+  });
+}
+
+template <>
+void callbackWithResponse(CallbackId result, ErrorCode code, int8_t response) {
+  invoker->invokeAsync([result, code, response]() {
+    State *_state = reinterpret_cast<State *>(result);
+    State *state = static_cast<State *>(_state);
+    jsi::Function *cb = &state->cb;
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime *>(state->rt);
+
+    auto out = createReturnValue(*rt, code, &response);
+    cb->call(*rt, out);
+  });
+}
+
+template <>
+void callbackWithResponse(CallbackId result, ErrorCode code, int64_t response) {
+  invoker->invokeAsync([result, code, response]() {
+    State *_state = reinterpret_cast<State *>(result);
+    State *state = static_cast<State *>(_state);
+    jsi::Function *cb = &state->cb;
+    jsi::Runtime *rt = reinterpret_cast<jsi::Runtime *>(state->rt);
+
+    auto out = createReturnValue(*rt, code, &response);
+    cb->call(*rt, out);
+  });
+}
+
+template <>
+uint8_t jsiToValue(jsi::Runtime &rt, jsi::Object &options, const char *name,
+                   bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+  if ((value.isNull() || value.isUndefined()) && optional)
+    return 0;
+
+  if (value.isNumber())
+    return value.asNumber();
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "number");
+};
+
+template <>
+int8_t jsiToValue(jsi::Runtime &rt, jsi::Object &options, const char *name,
+                  bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+  if ((value.isNull() || value.isUndefined()) && optional)
+    return 0;
+
+  if (value.isNumber())
+    return value.asNumber();
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "number");
+};
+
+template <>
+std::string jsiToValue<std::string>(jsi::Runtime &rt, jsi::Object &options,
+                                    const char *name, bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+
+  if ((value.isNull() || value.isUndefined()) && optional)
+    return std::string();
+
+  if (value.isString()) {
+    auto x = value.asString(rt).utf8(rt);
+    return x;
+  }
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "string");
+}
+
+template <>
+int64_t jsiToValue(jsi::Runtime &rt, jsi::Object &options, const char *name,
+                   bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+  if ((value.isNull() || value.isUndefined()) && optional)
+    return 0;
+
+  if (value.isNumber())
+    return value.asNumber();
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "number");
+};
+
+template <>
+uint64_t jsiToValue(jsi::Runtime &rt, jsi::Object &options, const char *name,
+                    bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+  if ((value.isNull() || value.isUndefined()) && optional)
+    return 0;
+
+  if (value.isNumber())
+    return value.asNumber();
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "number");
+};
+
+template <>
+int32_t jsiToValue(jsi::Runtime &rt, jsi::Object &options, const char *name,
+                   bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+  if ((value.isNull() || value.isUndefined()) && optional)
+    return 0;
+
+  if (value.isNumber())
+    return value.asNumber();
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "number");
+};
+
+template <>
+uint32_t jsiToValue(jsi::Runtime &rt, jsi::Object &options, const char *name,
+                    bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+  if ((value.isNull() || value.isUndefined()) && optional)
+    return 0;
+
+  if (value.isNumber())
+    return value.asNumber();
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "number");
+};
+
+template <>
+KeyEntryListHandle jsiToValue(jsi::Runtime &rt, jsi::Object &options,
+                              const char *name, bool optional) {
+  std::string handle = jsiToValue<std::string>(rt, options, name, optional);
+  FfiKeyEntryList *ffiKeyEntryListPtr =
+      reinterpret_cast<FfiKeyEntryList *>(std::stol(handle));
+  KeyEntryListHandle keyEntryListHandle =
+      KeyEntryListHandle{._0 = ffiKeyEntryListPtr};
+
+  return keyEntryListHandle;
+};
+
+template <>
+EntryListHandle jsiToValue(jsi::Runtime &rt, jsi::Object &options,
+                           const char *name, bool optional) {
+  std::string handle = jsiToValue<std::string>(rt, options, name, optional);
+  FfiEntryList *ffiEntryListPtr =
+      reinterpret_cast<FfiEntryList *>(std::stol(handle));
+  EntryListHandle entryListHandle = EntryListHandle{._0 = ffiEntryListPtr};
+
+  return entryListHandle;
+};
+
+template <>
+StringListHandle jsiToValue(jsi::Runtime &rt, jsi::Object &options,
+                           const char *name, bool optional) {
+  std::string handle = jsiToValue<std::string>(rt, options, name, optional);
+  FfiStringList *ffiStringListPtr =
+      reinterpret_cast<FfiStringList *>(std::stol(handle));
+  StringListHandle stringListHandle = StringListHandle{._0 = ffiStringListPtr};
+
+  return stringListHandle;
+};
+
+template <>
+LocalKeyHandle jsiToValue(jsi::Runtime &rt, jsi::Object &options,
+                          const char *name, bool optional) {
+  std::string handle = jsiToValue<std::string>(rt, options, name, optional);
+  LocalKey *localKeyPtr = reinterpret_cast<LocalKey *>(std::stol(handle));
+  LocalKeyHandle localKeyHandle = LocalKeyHandle{._0 = localKeyPtr};
+
+  return localKeyHandle;
+};
+
+template <>
+std::vector<int32_t>
+jsiToValue<std::vector<int32_t>>(jsi::Runtime &rt, jsi::Object &options,
+                                 const char *name, bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+
+  if (value.isObject() && value.asObject(rt).isArray(rt)) {
+    std::vector<int32_t> vec = {};
+    jsi::Array arr = value.asObject(rt).asArray(rt);
+    size_t length = arr.length(rt);
+    for (int i = 0; i < length; i++) {
+      jsi::Value element = arr.getValueAtIndex(rt, i);
+      if (element.isNumber()) {
+        vec.push_back(element.asNumber());
+      } else {
+        throw jsi::JSError(rt, errorPrefix + name + errorInfix + "number");
+      }
+    }
+    return vec;
+  }
+
+  if (optional)
+    return {};
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "Array<number>");
+}
+
+template <>
+ByteBuffer jsiToValue<ByteBuffer>(jsi::Runtime &rt, jsi::Object &options,
+                                  const char *name, bool optional) {
+  jsi::Value value = options.getProperty(rt, name);
+
+  if (value.isObject() && value.asObject(rt).isArrayBuffer(rt)) {
+    jsi::ArrayBuffer arrayBuffer = value.getObject(rt).getArrayBuffer(rt);
+    return ByteBuffer{int(arrayBuffer.size(rt)), arrayBuffer.data(rt)};
+  }
+
+  if (optional)
+    return ByteBuffer{0, 0};
+
+  throw jsi::JSError(rt, errorPrefix + name + errorInfix + "Uint8Array");
+}
+
+jsi::ArrayBuffer byteBufferToArrayBuffer(jsi::Runtime &rt, ByteBuffer bb) {
+  jsi::ArrayBuffer arrayBuffer = rt.global()
+                                     .getPropertyAsFunction(rt, "ArrayBuffer")
+                                     .callAsConstructor(rt, int(bb.len))
+                                     .getObject(rt)
+                                     .getArrayBuffer(rt);
+
+  memcpy(arrayBuffer.data(rt), bb.data, bb.len);
+  return arrayBuffer;
+}
+
+jsi::ArrayBuffer secretBufferToArrayBuffer(jsi::Runtime &rt, SecretBuffer sb) {
+  jsi::ArrayBuffer arrayBuffer = rt.global()
+                                     .getPropertyAsFunction(rt, "ArrayBuffer")
+                                     .callAsConstructor(rt, int(sb.len))
+                                     .getObject(rt)
+                                     .getArrayBuffer(rt);
+
+  memcpy(arrayBuffer.data(rt), sb.data, sb.len);
+  return arrayBuffer;
+}
+
+} // namespace askarTurboModuleUtility

package/cpp/turboModuleUtility.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+#include "HostObject.h"
+// TODO(rename): when lib has changed
+#include "include/libaries_askar.h"
+
+using namespace facebook;
+
+namespace askarTurboModuleUtility {
+
+static const std::string errorPrefix = "Value `";
+static const std::string errorInfix = "` is not of type ";
+
+// state of a callback function
+struct State {
+  jsi::Function cb;
+  jsi::Runtime *rt;
+
+  State(jsi::Function *cb_) : cb(std::move(*cb_)) {}
+};
+
+// Install the Turbomodule
+void registerTurboModule(jsi::Runtime &rt,
+                         std::shared_ptr<react::CallInvoker> jsCallInvoker);
+
+// Asserts that a jsi::Value is an object and can be safely transformed
+void assertValueIsObject(jsi::Runtime &rt, const jsi::Value *val);
+
+// Converts jsi values to regular cpp values
+template <typename T>
+T jsiToValue(jsi::Runtime &rt, jsi::Object &options, const char *name,
+             bool optional = false);
+
+// Callback function that makes the host function async
+void callback(CallbackId result, ErrorCode code);
+
+// Callback function that makes the host function async with response from rust
+// side
+template <typename T>
+void callbackWithResponse(CallbackId result, ErrorCode code, T response);
+
+// Instantiate a return object for JS side.
+// ```typescript
+// type ReturnObject = {
+//   errorCode: number
+//   value?: unknown | null
+// }
+// ```
+//
+// Value will be defined if there is no error.
+// Value will be `null` if there is no value to return
+// Value will be undefined if there is an error, e.g. error code != 0
+template <typename T>
+jsi::Value createReturnValue(jsi::Runtime &rt, ErrorCode code, T out);
+
+jsi::ArrayBuffer byteBufferToArrayBuffer(jsi::Runtime &rt, ByteBuffer bb);
+jsi::ArrayBuffer secretBufferToArrayBuffer(jsi::Runtime &rt, SecretBuffer sb);
+
+} // namespace askarTurboModuleUtility

package/ios/Askar.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface Askar : NSObject <RCTBridgeModule>
+
+@end

package/ios/Askar.mm

@@ -0,0 +1,33 @@
+#import <React/RCTBridge+Private.h>
+#import <jsi/jsi.h>
+#import <React/RCTUtils.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <askar/turboModuleUtility.h>
+
+#import "Askar.h"
+
+using namespace facebook;
+
+@implementation Askar 
+
+RCT_EXPORT_MODULE()
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
+{
+    RCTBridge* bridge = [RCTBridge currentBridge];
+    RCTCxxBridge* cxxBridge = (RCTCxxBridge*)bridge;
+    if (cxxBridge == nil) {
+        return @false;
+    }
+    
+    jsi::Runtime* jsiRuntime = (jsi::Runtime*) cxxBridge.runtime;
+    if (jsiRuntime == nil) {
+        return @false;
+    }
+    
+    auto callInvoker = bridge.jsCallInvoker;
+    askarTurboModuleUtility::registerTurboModule(*jsiRuntime, callInvoker);
+    return @true;
+}
+
+@end