diff --git a/README.md b/README.md
index 0a1e222..9a4d8db 100644
--- a/README.md
+++ b/README.md
@@ -10,12 +10,12 @@
 ## JSI
 
 
-If you want to use with `JSI` instead of `NativeModules` you need to set
+If you want to use with `NativeModules` instead of `JSI` you need to set
 
 ```typescript
 import RSA from "react-native-fast-rsa";
 
-RSA.useJSI = true;
+RSA.useJSI = false;
 ```
 if you need to use generate methods it is a good idea to disable it, because for now JSI will block your UI but it is faster compared to NativeModules
 
@@ -78,15 +78,27 @@ class RSA {
   static decryptOAEP(message: string, label: string, hashName: Hash, privateKey: string): Promise<string>
   static decryptPKCS1v15(message: string, privateKey: string,): Promise<string>
 
+  static decryptOAEPBytes(message: Uint8Array, label: string, hashName: Hash, privateKey: string): Promise<Uint8Array>
+  static decryptPKCS1v15Bytes(message: Uint8Array, privateKey: string,): Promise<Uint8Array>
+
   static encryptOAEP(message: string,label: string, hashName: Hash, publicKey: string): Promise<string>
   static encryptPKCS1v15(message: string, publicKey: string): Promise<string>
 
+  static encryptOAEPBytes(message: Uint8Array,label: string, hashName: Hash, publicKey: string): Promise<Uint8Array>
+  static encryptPKCS1v15Bytes(message: Uint8Array, publicKey: string): Promise<Uint8Array>
+
   static signPSS(message: string, hashName: Hash, saltLengthName: SaltLength, privateKey: string): Promise<string>
   static signPKCS1v15(message: string, hashName: Hash, privateKey: string): Promise<string>
 
+  static signPSSBytes(message: Uint8Array, hashName: Hash, saltLengthName: SaltLength, privateKey: string): Promise<Uint8Array>
+  static signPKCS1v15Bytes(message: Uint8Array, hashName: Hash, privateKey: string): Promise<Uint8Array>
+
   static verifyPSS(signature: string, message: string, hashName: Hash, saltLengthName: SaltLength, publicKey: string): Promise<boolean>
   static verifyPKCS1v15(signature: string, message: string, hashName: Hash, publicKey: string): Promise<boolean>
 
+  static verifyPSSBytes(signature: Uint8Array, message: Uint8Array, hashName: Hash, saltLengthName: SaltLength, publicKey: string): Promise<boolean>
+  static verifyPKCS1v15Bytes(signature: Uint8Array, message: Uint8Array, hashName: Hash, publicKey: string): Promise<boolean>
+
   static hash(message: string, name: Hash): Promise<string>
   static base64(message: string): Promise<string>
 
diff --git a/android/fast-rsa-adapter.cpp b/android/fast-rsa-adapter.cpp
index 88c3566..385ca95 100644
--- a/android/fast-rsa-adapter.cpp
+++ b/android/fast-rsa-adapter.cpp
@@ -93,4 +93,97 @@ Java_com_fastrsa_FastRsaModule_callNative(JNIEnv* env,
   free(response);
 
   return result;
+}
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_fastrsa_FastRsaModule_encodeTextNative(JNIEnv* env, jobject thiz, jstring input, jstring encoding) {
+    if (input == nullptr || encoding == nullptr) {
+        jclass Exception = env->FindClass("java/lang/NullPointerException");
+        env->ThrowNew(Exception, "Input parameters 'input' or 'encoding' cannot be null");
+        return nullptr;
+    }
+
+    // Convert Java Strings to C Strings
+    const char* inputCStr = env->GetStringUTFChars(input, nullptr);
+    const char* encodingCStr = env->GetStringUTFChars(encoding, nullptr);
+
+    if (inputCStr == nullptr || encodingCStr == nullptr) {
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'input' or 'encoding'");
+        return nullptr;
+    }
+
+    // Call the shared library function
+    BytesReturn* response = RSAEncodeText(const_cast<char*>(inputCStr), const_cast<char*>(encodingCStr));
+
+    // Release allocated resources
+    env->ReleaseStringUTFChars(input, inputCStr);
+    env->ReleaseStringUTFChars(encoding, encodingCStr);
+
+    if (response->error != nullptr) {
+        jclass Exception = env->FindClass("java/lang/Exception");
+        env->ThrowNew(Exception, response->error);
+        free(response);
+        return nullptr;
+    }
+
+    // Create a new byte array to return the encoded data
+    jbyteArray result = env->NewByteArray(response->size);
+    if (result == nullptr) {
+        free(response);
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for result");
+        return nullptr;
+    }
+
+    env->SetByteArrayRegion(result, 0, response->size, reinterpret_cast<jbyte*>(response->message));
+    free(response);
+
+    return result;
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_fastrsa_FastRsaModule_decodeTextNative(JNIEnv* env, jobject thiz, jbyteArray input, jstring encoding, 
+                                          jint fatal, jint ignoreBOM, jint stream) {
+    if (input == nullptr || encoding == nullptr) {
+        jclass Exception = env->FindClass("java/lang/NullPointerException");
+        env->ThrowNew(Exception, "Input parameters 'input' or 'encoding' cannot be null");
+        return nullptr;
+    }
+
+    // Convert Java Strings to C Strings
+    const char* encodingCStr = env->GetStringUTFChars(encoding, nullptr);
+    if (encodingCStr == nullptr) {
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'encoding'");
+        return nullptr;
+    }
+
+    // Convert Java byte array to C byte array
+    jsize size = env->GetArrayLength(input);
+    jbyte* inputBytes = env->GetByteArrayElements(input, nullptr);
+    if (inputBytes == nullptr) {
+        env->ReleaseStringUTFChars(encoding, encodingCStr);
+        jclass Exception = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(Exception, "Failed to allocate memory for 'input'");
+        return nullptr;
+    }
+
+    // Call the shared library function
+    char* decodedString = RSADecodeText(inputBytes, size, const_cast<char*>(encodingCStr), fatal, ignoreBOM, stream);
+
+    // Release resources
+    env->ReleaseStringUTFChars(encoding, encodingCStr);
+    env->ReleaseByteArrayElements(input, inputBytes, JNI_ABORT);
+
+    if (decodedString == nullptr) {
+        jclass Exception = env->FindClass("java/lang/Exception");
+        env->ThrowNew(Exception, "Decoding failed");
+        return nullptr;
+    }
+
+    // Convert C string to Java string and return
+    jstring result = env->NewStringUTF(decodedString);
+    free(decodedString);
+    return result;
 }
\ No newline at end of file
diff --git a/android/src/main/java/com/fastrsa/FastRsaModule.kt b/android/src/main/java/com/fastrsa/FastRsaModule.kt
index 1eeb912..0716067 100644
--- a/android/src/main/java/com/fastrsa/FastRsaModule.kt
+++ b/android/src/main/java/com/fastrsa/FastRsaModule.kt
@@ -11,6 +11,8 @@ internal class FastRsaModule(reactContext: ReactApplicationContext) :
   external fun initialize(jsContext: Long)
   external fun destruct();
   external fun callNative(name: String, payload: ByteArray): ByteArray;
+  external fun encodeTextNative(input: String, encoding: String): ByteArray
+  external fun decodeTextNative(input: ByteArray, encoding: String, fatal: Int, ignoreBOM: Int, stream: Int): String
 
   companion object {
     init {
@@ -41,6 +43,32 @@ internal class FastRsaModule(reactContext: ReactApplicationContext) :
     }.start()
   }
 
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun encodeText(input: String, encoding: String): WritableArray {
+      return try {
+          val result = encodeTextNative(input, encoding) 
+          Arguments.createArray().apply {
+              result.forEach { byteValue: Byte -> pushInt(byteValue.toInt() and 0xFF) } 
+          }
+      } catch (e: Exception) {
+          Log.e(TAG, "Encoding error", e)
+          throw RuntimeException("ENCODE_ERROR: Failed to encode text")
+      }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun decodeText(input: ReadableArray, encoding: String, fatal: Boolean, ignoreBOM: Boolean, stream: Boolean): String {
+      return try {
+          val bytes = ByteArray(input.size()) { index ->
+              input.getInt(index).toByte()
+          }
+          decodeTextNative(bytes, encoding, if (fatal) 1 else 0, if (ignoreBOM) 1 else 0, if (stream) 1 else 0)
+      } catch (e: Exception) {
+          Log.e(TAG, "Decoding error", e)
+          throw RuntimeException("DECODE_ERROR: Failed to decode text")
+      }
+  }
+
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun install(): Boolean {
       Log.d(TAG, "Attempting to install JSI bindings...")
diff --git a/android/src/main/jniLibs/arm64-v8a/librsa_bridge.h b/android/src/main/jniLibs/arm64-v8a/librsa_bridge.h
index ff18cc0..8d24849 100644
--- a/android/src/main/jniLibs/arm64-v8a/librsa_bridge.h
+++ b/android/src/main/jniLibs/arm64-v8a/librsa_bridge.h
@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }
diff --git a/android/src/main/jniLibs/arm64-v8a/librsa_bridge.so b/android/src/main/jniLibs/arm64-v8a/librsa_bridge.so
index 4522f16..4791421 100644
Binary files a/android/src/main/jniLibs/arm64-v8a/librsa_bridge.so and b/android/src/main/jniLibs/arm64-v8a/librsa_bridge.so differ
diff --git a/android/src/main/jniLibs/armeabi-v7a/librsa_bridge.h b/android/src/main/jniLibs/armeabi-v7a/librsa_bridge.h
index ca87c85..76535ca 100644
--- a/android/src/main/jniLibs/armeabi-v7a/librsa_bridge.h
+++ b/android/src/main/jniLibs/armeabi-v7a/librsa_bridge.h
@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }
diff --git a/android/src/main/jniLibs/armeabi-v7a/librsa_bridge.so b/android/src/main/jniLibs/armeabi-v7a/librsa_bridge.so
index a4981d6..81bebd5 100644
Binary files a/android/src/main/jniLibs/armeabi-v7a/librsa_bridge.so and b/android/src/main/jniLibs/armeabi-v7a/librsa_bridge.so differ
diff --git a/android/src/main/jniLibs/x86/librsa_bridge.h b/android/src/main/jniLibs/x86/librsa_bridge.h
index ca87c85..76535ca 100644
--- a/android/src/main/jniLibs/x86/librsa_bridge.h
+++ b/android/src/main/jniLibs/x86/librsa_bridge.h
@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }
diff --git a/android/src/main/jniLibs/x86/librsa_bridge.so b/android/src/main/jniLibs/x86/librsa_bridge.so
index 06c804f..ee1c862 100644
Binary files a/android/src/main/jniLibs/x86/librsa_bridge.so and b/android/src/main/jniLibs/x86/librsa_bridge.so differ
diff --git a/android/src/main/jniLibs/x86_64/librsa_bridge.h b/android/src/main/jniLibs/x86_64/librsa_bridge.h
index ff18cc0..8d24849 100644
--- a/android/src/main/jniLibs/x86_64/librsa_bridge.h
+++ b/android/src/main/jniLibs/x86_64/librsa_bridge.h
@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }
diff --git a/android/src/main/jniLibs/x86_64/librsa_bridge.so b/android/src/main/jniLibs/x86_64/librsa_bridge.so
index bf4aee0..ab391db 100644
Binary files a/android/src/main/jniLibs/x86_64/librsa_bridge.so and b/android/src/main/jniLibs/x86_64/librsa_bridge.so differ
diff --git a/cpp/librsa_bridge.h b/cpp/librsa_bridge.h
index 6212809..fd55b61 100644
--- a/cpp/librsa_bridge.h
+++ b/cpp/librsa_bridge.h
@@ -10,6 +10,8 @@ typedef struct {
 extern "C" {
 #endif
 extern BytesReturn* RSABridgeCall(char* p0, void* p1, int p2);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 #ifdef __cplusplus
 }
 #endif
diff --git a/cpp/react-native-fast-rsa.cpp b/cpp/react-native-fast-rsa.cpp
index 20c78ae..f2a2645 100644
--- a/cpp/react-native-fast-rsa.cpp
+++ b/cpp/react-native-fast-rsa.cpp
@@ -5,7 +5,6 @@
 #include <future>
 #include <iostream>
 #include <sstream>
-#include <future> 
 #include <thread>
 
 #include "librsa_bridge.h"
@@ -13,6 +12,61 @@
 using namespace facebook;
 
 namespace fastRSA {
+
+jsi::Value encodeText(jsi::Runtime &runtime, const jsi::String &inputValue, const jsi::String &encodingValue) {
+  std::string inputString = inputValue.utf8(runtime);
+  std::string encodingString = encodingValue.utf8(runtime);
+
+  std::vector<char> mutableInput(inputString.begin(), inputString.end());
+  mutableInput.push_back('\0');
+  std::vector<char> mutableEncoding(encodingString.begin(), encodingString.end());
+  mutableEncoding.push_back('\0');
+
+  auto response = RSAEncodeText(mutableInput.data(), mutableEncoding.data());
+  if (response->error != nullptr) {
+    std::string errorMessage(response->error);
+    free(response);
+    throw jsi::JSError(runtime, errorMessage);
+  }
+
+  auto uint8ArrayConstructor = runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
+  jsi::Object uint8ArrayObject = uint8ArrayConstructor.callAsConstructor(runtime, response->size).getObject(runtime);
+  jsi::ArrayBuffer arrayBuffer = uint8ArrayObject.getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  memcpy(arrayBuffer.data(runtime), response->message, response->size);
+
+  free(response);
+  return uint8ArrayObject;
+}
+
+jsi::Value decodeText(jsi::Runtime &runtime, const jsi::Object &inputObject, const jsi::String &encodingValue,
+                      bool fatal, bool ignoreBOM, bool stream) {
+  auto uint8ArrayConstructor = runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
+  if (!inputObject.instanceOf(runtime, uint8ArrayConstructor)) {
+    throw jsi::JSError(runtime, "First argument must be a Uint8Array");
+  }
+
+  // Get Uint8Array data
+  jsi::ArrayBuffer arrayBuffer = inputObject.getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  int byteOffset = inputObject.getProperty(runtime, "byteOffset").asNumber();
+  int length = inputObject.getProperty(runtime, "byteLength").asNumber();
+
+  uint8_t *dataPointer = static_cast<uint8_t *>(arrayBuffer.data(runtime)) + byteOffset;
+
+  std::string encodingString = encodingValue.utf8(runtime);
+  std::vector<char> mutableEncoding(encodingString.begin(), encodingString.end());
+  mutableEncoding.push_back('\0');
+
+  char *decodedString = RSADecodeText(dataPointer, length, mutableEncoding.data(), fatal ? 1 : 0, ignoreBOM ? 1 : 0, stream ? 1 : 0);
+  if (!decodedString) {
+    throw jsi::JSError(runtime, "Failed to decode text");
+  }
+
+  jsi::String result = jsi::String::createFromUtf8(runtime, decodedString);
+  free(decodedString);
+  return result;
+}
+
+
 jsi::Value call(jsi::Runtime &runtime, const jsi::String &nameValue,
                 const jsi::Object &payloadObject) {
   // Extract and validate name
@@ -140,6 +194,8 @@ void install(jsi::Runtime &jsiRuntime) {
                 reject.call(runtime, error.value());
               } catch (const std::exception &e) {
                 reject.call(runtime, jsi::String::createFromUtf8(runtime, e.what()));
+              } catch (...) {
+                reject.call(runtime, jsi::String::createFromUtf8(runtime, "Unknown error occurred"));
               }
 
               return jsi::Value::undefined();
@@ -152,6 +208,35 @@ void install(jsi::Runtime &jsiRuntime) {
         return promise;
       });
 
+  auto encodeTextFunc = jsi::Function::createFromHostFunction(
+        jsiRuntime, jsi::PropNameID::forAscii(jsiRuntime, "encodeText"), 2,
+        [](jsi::Runtime &runtime, const jsi::Value & /*thisValue*/, const jsi::Value *arguments, size_t count) -> jsi::Value {
+          if (count != 2) {
+            throw jsi::JSError(runtime, "encodeText expects exactly 2 arguments: (string input, string encoding)");
+          }
+          if (!arguments[0].isString() || !arguments[1].isString()) {
+            throw jsi::JSError(runtime, "Both arguments must be strings");
+          }
+          return encodeText(runtime, arguments[0].getString(runtime), arguments[1].getString(runtime));
+        });
+  
+  auto decodeTextFunc = jsi::Function::createFromHostFunction(
+      jsiRuntime, jsi::PropNameID::forAscii(jsiRuntime, "decodeText"), 5,
+      [](jsi::Runtime &runtime, const jsi::Value & /*thisValue*/, const jsi::Value *arguments, size_t count) -> jsi::Value {
+        if (count != 5) {
+          throw jsi::JSError(runtime, "decodeText expects exactly 5 arguments: (Uint8Array input, string encoding, bool fatal, bool ignoreBOM, bool stream)");
+        }
+        if (!arguments[0].isObject() || !arguments[0].getObject(runtime).instanceOf(runtime, runtime.global().getPropertyAsFunction(runtime, "Uint8Array")) ||
+            !arguments[1].isString() || !arguments[2].isBool() || !arguments[3].isBool() || !arguments[4].isBool()) {
+          throw jsi::JSError(runtime, "Invalid argument types");
+        }
+
+        return decodeText(runtime, arguments[0].getObject(runtime),
+                          arguments[1].getString(runtime), arguments[2].getBool(), arguments[3].getBool(), arguments[4].getBool());
+      });
+  
+  jsiRuntime.global().setProperty(jsiRuntime, "FastRSAEncodeText", std::move(encodeTextFunc));
+  jsiRuntime.global().setProperty(jsiRuntime, "FastRSADecodeText", std::move(decodeTextFunc));
   jsiRuntime.global().setProperty(jsiRuntime, "FastRSACallPromise", std::move(bridgeCallPromise));
   jsiRuntime.global().setProperty(jsiRuntime, "FastRSACallSync", std::move(bridgeCallSync));
 }
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
index ef54c43..4bf785d 100644
--- a/example/ios/Podfile.lock
+++ b/example/ios/Podfile.lock
@@ -315,7 +315,7 @@ PODS:
   - React-jsinspector (0.72.6)
   - React-logger (0.72.6):
     - glog
-  - react-native-fast-rsa (2.5.0):
+  - react-native-fast-rsa (2.6.0):
     - RCT-Folly (= 2021.07.22.00)
     - React-Core
   - React-NativeModulesApple (0.72.6):
@@ -578,23 +578,23 @@ SPEC CHECKSUMS:
   RCTTypeSafety: e9c6c409fca2cc584e5b086862d562540cb38d29
   React: 769f469909b18edfe934f0539fffb319c4c61043
   React-callinvoker: e48ce12c83706401251921896576710d81e54763
-  React-Codegen: a136b8094d39fd071994eaa935366e6be2239cb1
-  React-Core: e548a186fb01c3a78a9aeeffa212d625ca9511bf
-  React-CoreModules: d226b22d06ea1bc4e49d3c073b2c6cbb42265405
-  React-cxxreact: 44a3560510ead6633b6e02f9fbbdd1772fb40f92
+  React-Codegen: 09c4a6d0a6ba9f7d008ac3a5e7c202899178ce20
+  React-Core: 4d03a504696413bc97ef8a9085f642555867eed8
+  React-CoreModules: 93be55ffed8b41ed664b51072498a23d9261410b
+  React-cxxreact: ac5508f2887a7eeb93dd9675e2cfc2b20b379936
   React-debug: 238501490155574ae9f3f8dd1c74330eba30133e
-  React-hermes: 46e66dc854124d7645c20bfec0a6be9542826ecd
-  React-jsi: fbdaf4166bae60524b591b18c851b530c8cdb90c
-  React-jsiexecutor: 3bf18ff7cb03cd8dfdce08fbbc0d15058c1d71ae
+  React-hermes: 2dc01922de59f0e21230aedc51d5adef7d7f76f6
+  React-jsi: 11012bf34366812063bd16ca739ca219af26680f
+  React-jsiexecutor: 5b6dd84e7461ae0bd999922cafe1fe3f98ced073
   React-jsinspector: 194e32c6aab382d88713ad3dd0025c5f5c4ee072
-  React-logger: cebf22b6cf43434e471dc561e5911b40ac01d289
-  react-native-fast-rsa: a2151e7c9167ad4d2cd1c9592787d37de493e269
-  React-NativeModulesApple: 02e35e9a51e10c6422f04f5e4076a7c02243fff2
+  React-logger: 39440454dfd719978689203a9d18b94e98de09eb
+  react-native-fast-rsa: 80bc0b93c19bcf2b732522c38185ddb2c33ea332
+  React-NativeModulesApple: 90508a0d94b0b66bb2ba14bc3bef65a00f5a8efb
   React-perflogger: e3596db7e753f51766bceadc061936ef1472edc3
   React-RCTActionSheet: 17ab132c748b4471012abbcdcf5befe860660485
   React-RCTAnimation: c8bbaab62be5817d2a31c36d5f2571e3f7dcf099
-  React-RCTAppDelegate: af1c7dace233deba4b933cd1d6491fe4e3584ad1
-  React-RCTBlob: 1bcf3a0341eb8d6950009b1ddb8aefaf46996b8c
+  React-RCTAppDelegate: c06dfd41e63ef630220dc1892f77c277bba84a98
+  React-RCTBlob: 56f3c13b80c8b415ad1f81881fcab44904abe07c
   React-RCTImage: 670a3486b532292649b1aef3ffddd0b495a5cee4
   React-RCTLinking: bd7ab853144aed463903237e615fd91d11b4f659
   React-RCTNetwork: be86a621f3e4724758f23ad1fdce32474ab3d829
@@ -603,9 +603,9 @@ SPEC CHECKSUMS:
   React-RCTVibration: 6bd85328388ac2e82ae0ca11afe48ad5555b483a
   React-rncore: fda7b1ae5918fa7baa259105298a5487875a57c8
   React-runtimeexecutor: 57d85d942862b08f6d15441a0badff2542fd233c
-  React-runtimescheduler: f23e337008403341177fc52ee4ca94e442c17ede
-  React-utils: fa59c9a3375fb6f4aeb66714fd3f7f76b43a9f16
-  ReactCommon: dd03c17275c200496f346af93a7b94c53f3093a4
+  React-runtimescheduler: 8d48e9f0cf62099f501fcd52234240006fa12c8f
+  React-utils: ee4e6bf16d6882500500d517d36f9035874c5f6a
+  ReactCommon: 2060ee7b68e71d23849968f6406550ba2df71bdb
   SocketRocket: f32cd54efbe0f095c4d7594881e52619cfe80b17
   Yoga: b76f1acfda8212aa16b7e26bcce3983230c82603
 
diff --git a/example/src/App.tsx b/example/src/App.tsx
index 81834cd..6933b04 100644
--- a/example/src/App.tsx
+++ b/example/src/App.tsx
@@ -23,6 +23,7 @@ import ConvertPrivate from './modules/ConvertPrivate';
 import ConvertJWT from './modules/ConvertJWT';
 import ConvertKeyPair from './modules/ConvertKeyPair';
 import RSA from 'react-native-fast-rsa';
+import EncryptDecryptOAEPBytes from './modules/EncryptDecryptOAEPBytes';
 
 const passphrase = 'test';
 const privateKey = `-----BEGIN RSA PRIVATE KEY-----
@@ -88,6 +89,11 @@ const App = () => {
                 privateKey={privateKey}
                 passphrase={passphrase}
               />
+              <EncryptDecryptOAEPBytes
+                publicKey={publicKey}
+                privateKey={privateKey}
+                passphrase={passphrase}
+              />
               <EncryptDecryptPKCS
                 publicKey={publicKey}
                 privateKey={privateKey}
diff --git a/example/src/modules/EncryptDecryptOAEPBytes.tsx b/example/src/modules/EncryptDecryptOAEPBytes.tsx
new file mode 100644
index 0000000..7df8f65
--- /dev/null
+++ b/example/src/modules/EncryptDecryptOAEPBytes.tsx
@@ -0,0 +1,86 @@
+import {Colors} from "react-native/Libraries/NewAppScreen";
+import {Button, TextInput} from "react-native";
+import React, {useState} from "react";
+import RSA, { Hash } from 'react-native-fast-rsa';
+import SectionContainer from "../components/SectionContainer";
+import SectionTitle from "../components/SectionTitle";
+import SectionResult from "../components/SectionResult";
+import Container from "../components/Container";
+import { base64Encode, uint8ArrayToString } from "../utils/codecs";
+
+interface Props {
+    publicKey: string,
+    privateKey: string,
+    passphrase: string
+}
+
+export default function ({publicKey, privateKey}: Props) {
+
+    const [input, setInput] = useState<Uint8Array | undefined>();
+    const [encrypted, setEncrypted] = useState<Uint8Array | undefined>();
+    const [decrypted, setDecrypted] = useState<Uint8Array | undefined>();
+
+    return <Container testID={'encrypt-decrypt-oaep-bytes'}>
+        <SectionContainer testID={'encrypt'}>
+            <SectionTitle>Encrypt OAEP Bytes</SectionTitle>
+            <TextInput
+                testID={'message'}
+                onChangeText={(text) => {
+                    const encoded = new global.TextEncoder().encode(text);
+                    setInput(encoded);
+                }}
+                style={{backgroundColor: Colors.white, borderRadius: 4}}
+                placeholder={"insert message here"}
+            />
+            <Button
+                title={"Encrypt"}
+                testID={'button'}
+                onPress={async () => {
+                    if (!input) {
+                        return;
+                    }
+                    const output = await RSA.encryptOAEPBytes(input,"sample",Hash.SHA256, publicKey);
+                    setEncrypted(output);
+                }}
+            />
+            {!!encrypted && (
+                <SectionResult testID={'result-raw'}>
+                    bytes: {encrypted.join(", ")}
+                </SectionResult>
+            )}
+            {!!encrypted && (
+                <SectionResult testID={'result'}>
+                    base64: {base64Encode(encrypted)}
+                </SectionResult>
+            )}
+        </SectionContainer>
+        {!!encrypted && (
+            <SectionContainer testID={'decrypt'}>
+                <SectionTitle>Decrypt OAEP Bytes</SectionTitle>
+                <Button
+                    title={"Decrypt"}
+                    testID={'button'}
+                    onPress={async () => {
+                        const output = await RSA.decryptOAEPBytes(
+                            encrypted,
+                            "sample",
+                            Hash.SHA256,
+                            privateKey
+                        );
+                        setDecrypted(output);
+                    }}
+                />
+                {!!decrypted && (
+                    <SectionResult testID={'result-raw'}>
+                        bytes: {decrypted.join(", ")}
+                    </SectionResult>
+                )}
+                {!!decrypted && (
+                    <SectionResult testID={'result'}>
+                        decoded: {uint8ArrayToString(decrypted)}
+                    </SectionResult>
+                )}
+            </SectionContainer>
+        )}
+    </Container>;
+}
diff --git a/example/src/utils/base64.ts b/example/src/utils/base64.ts
new file mode 100644
index 0000000..02b3262
--- /dev/null
+++ b/example/src/utils/base64.ts
@@ -0,0 +1,104 @@
+const keyStr: string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+export default {
+    encode: function (input: string): string {
+        const output: string[] = [];
+        let chr1: number, chr2: number, chr3: number;
+        let enc1: number, enc2: number, enc3: number, enc4: number;
+        let i = 0;
+
+        do {
+            chr1 = input.charCodeAt(i++);
+            chr2 = input.charCodeAt(i++);
+            chr3 = input.charCodeAt(i++);
+
+            enc1 = chr1 >> 2;
+            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+            enc4 = chr3 & 63;
+
+            if (isNaN(chr2)) {
+                enc3 = enc4 = 64;
+            } else if (isNaN(chr3)) {
+                enc4 = 64;
+            }
+
+            output.push(
+                keyStr.charAt(enc1) +
+                keyStr.charAt(enc2) +
+                keyStr.charAt(enc3) +
+                keyStr.charAt(enc4)
+            );
+        } while (i < input.length);
+
+        return output.join('');
+    },
+
+    encodeFromByteArray: function (input: Uint8Array): string {
+        const output: string[] = [];
+        let chr1: any, chr2: any, chr3: any;
+        let enc1: number, enc2: number, enc3: number, enc4: number;
+        let i = 0;
+
+        do {
+            chr1 = input[i++];
+            chr2 = input[i++];
+            chr3 = input[i++];
+
+            enc1 = chr1 >> 2;
+            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+            enc4 = chr3 & 63;
+
+            if (isNaN(chr2)) {
+                enc3 = enc4 = 64;
+            } else if (isNaN(chr3)) {
+                enc4 = 64;
+            }
+
+            output.push(
+                keyStr.charAt(enc1) +
+                keyStr.charAt(enc2) +
+                keyStr.charAt(enc3) +
+                keyStr.charAt(enc4)
+            );
+        } while (i < input.length);
+
+        return output.join('');
+    },
+
+    decode: function (input: string): string {
+        let output = "";
+        let chr1: number, chr2: number, chr3: number;
+        let enc1: number, enc2: number, enc3: number, enc4: number;
+        let i = 0;
+
+        const base64test = /[^A-Za-z0-9\+\/\=]/g;
+        if (base64test.exec(input)) {
+            throw new Error("Invalid base64 characters in input text.");
+        }
+        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+
+        do {
+            enc1 = keyStr.indexOf(input.charAt(i++));
+            enc2 = keyStr.indexOf(input.charAt(i++));
+            enc3 = keyStr.indexOf(input.charAt(i++));
+            enc4 = keyStr.indexOf(input.charAt(i++));
+
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+
+            output += String.fromCharCode(chr1);
+
+            if (enc3 !== 64) {
+                output += String.fromCharCode(chr2);
+            }
+            if (enc4 !== 64) {
+                output += String.fromCharCode(chr3);
+            }
+        } while (i < input.length);
+
+        return output;
+    }
+};
diff --git a/example/src/utils/codecs.ts b/example/src/utils/codecs.ts
new file mode 100644
index 0000000..a04a13b
--- /dev/null
+++ b/example/src/utils/codecs.ts
@@ -0,0 +1,17 @@
+import base64 from "./base64";
+
+export function base64Encode(uint8Array:Uint8Array) {
+    let binary = '';
+    uint8Array.forEach(byte => {
+        binary += String.fromCharCode(byte);
+    });
+    return base64.encode(binary);
+}
+
+export function stringToUint8Array(str:string) {
+    return new global.TextEncoder().encode(str);
+}
+
+export function uint8ArrayToString(str:Uint8Array) {
+    return new global.TextDecoder().decode(str);
+}
diff --git a/ios/FastRsa.mm b/ios/FastRsa.mm
index 8465882..ec83b24 100644
--- a/ios/FastRsa.mm
+++ b/ios/FastRsa.mm
@@ -80,6 +80,75 @@ @implementation FastRsa
     resolve(result);
 }
 
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(encodeText:(NSString *)input encoding:(NSString *)encoding) {
+    // Convert NSString to C-string
+    char *cInput = strdup([input UTF8String]);
+    char *cEncoding = strdup([encoding UTF8String]);
+
+    if (!cInput || !cEncoding) {
+        if (cInput) free(cInput);
+        if (cEncoding) free(cEncoding);
+        return nil;
+    }
+
+    // Call the native encoding function
+    BytesReturn *response = RSAEncodeText(cInput, cEncoding);
+    free(cInput);
+    free(cEncoding);
+
+    if (!response) {
+        return nil;
+    }
+
+    if (response->error != NULL) {
+        free(response);
+        return nil;
+    }
+
+    // Convert response bytes to NSArray
+    NSMutableArray *result = [[NSMutableArray alloc] initWithCapacity:response->size];
+    for (int i = 0; i < response->size; i++) {
+        [result addObject:@(((Byte*)response->message)[i])];
+    }
+
+    free(response);
+    return result;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(decodeText:(NSArray *)input encoding:(NSString *)encoding fatal:(BOOL)fatal ignoreBOM:(BOOL)ignoreBOM stream:(BOOL)stream) {
+    // Convert NSArray to Byte array
+    Byte *bytesCopy = (Byte *)malloc(input.count);
+    if (!bytesCopy) {
+        return nil;
+    }
+
+    for (NSUInteger i = 0; i < input.count; i++) {
+        bytesCopy[i] = [input[i] intValue];
+    }
+
+    // Convert NSString to C-string
+    char *cEncoding = strdup([encoding UTF8String]);
+    if (!cEncoding) {
+        free(bytesCopy);
+        return nil;
+    }
+
+    // Call the native decoding function
+    char *decodedString = RSADecodeText(bytesCopy, (int)input.count, cEncoding, fatal ? 1 : 0, ignoreBOM ? 1 : 0, stream ? 1 : 0);
+    free(bytesCopy);
+    free(cEncoding);
+
+    if (!decodedString) {
+        return nil;
+    }
+
+    // Convert C-string to NSString
+    NSString *result = [NSString stringWithUTF8String:decodedString];
+    free(decodedString);
+    
+    return result;
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
     // Ensure the bridge is valid and of the expected type
diff --git a/ios/Rsa.xcframework/Info.plist b/ios/Rsa.xcframework/Info.plist
index cf4518a..73f994f 100644
--- a/ios/Rsa.xcframework/Info.plist
+++ b/ios/Rsa.xcframework/Info.plist
@@ -10,18 +10,15 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>librsa_bridge.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -48,15 +45,18 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>librsa_bridge.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>
diff --git a/ios/Rsa.xcframework/ios-arm64/Headers/librsa_bridge.h b/ios/Rsa.xcframework/ios-arm64/Headers/librsa_bridge.h
index ff18cc0..8d24849 100644
--- a/ios/Rsa.xcframework/ios-arm64/Headers/librsa_bridge.h
+++ b/ios/Rsa.xcframework/ios-arm64/Headers/librsa_bridge.h
@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }
diff --git a/ios/Rsa.xcframework/ios-arm64/librsa_bridge.a b/ios/Rsa.xcframework/ios-arm64/librsa_bridge.a
index da727c8..466e82b 100644
Binary files a/ios/Rsa.xcframework/ios-arm64/librsa_bridge.a and b/ios/Rsa.xcframework/ios-arm64/librsa_bridge.a differ
diff --git a/ios/Rsa.xcframework/ios-arm64_x86_64-maccatalyst/Headers/librsa_bridge.h b/ios/Rsa.xcframework/ios-arm64_x86_64-maccatalyst/Headers/librsa_bridge.h
index ff18cc0..8d24849 100644
--- a/ios/Rsa.xcframework/ios-arm64_x86_64-maccatalyst/Headers/librsa_bridge.h
+++ b/ios/Rsa.xcframework/ios-arm64_x86_64-maccatalyst/Headers/librsa_bridge.h
@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }
diff --git a/ios/Rsa.xcframework/ios-arm64_x86_64-maccatalyst/librsa_bridge.a b/ios/Rsa.xcframework/ios-arm64_x86_64-maccatalyst/librsa_bridge.a
index ea488ed..d568c24 100644
Binary files a/ios/Rsa.xcframework/ios-arm64_x86_64-maccatalyst/librsa_bridge.a and b/ios/Rsa.xcframework/ios-arm64_x86_64-maccatalyst/librsa_bridge.a differ
diff --git a/ios/Rsa.xcframework/ios-arm64_x86_64-simulator/Headers/librsa_bridge.h b/ios/Rsa.xcframework/ios-arm64_x86_64-simulator/Headers/librsa_bridge.h
index ff18cc0..8d24849 100644
--- a/ios/Rsa.xcframework/ios-arm64_x86_64-simulator/Headers/librsa_bridge.h
+++ b/ios/Rsa.xcframework/ios-arm64_x86_64-simulator/Headers/librsa_bridge.h
@@ -81,6 +81,8 @@ extern "C" {
 #endif
 
 extern BytesReturn* RSABridgeCall(char* name, void* payload, int payloadSize);
+extern BytesReturn* RSAEncodeText(char* input, char* encoding);
+extern char* RSADecodeText(void* input, int size, char* encoding, int fatal, int ignoreBOM, int stream);
 
 #ifdef __cplusplus
 }
diff --git a/ios/Rsa.xcframework/ios-arm64_x86_64-simulator/librsa_bridge.a b/ios/Rsa.xcframework/ios-arm64_x86_64-simulator/librsa_bridge.a
index d5f0ebc..b395e80 100644
Binary files a/ios/Rsa.xcframework/ios-arm64_x86_64-simulator/librsa_bridge.a and b/ios/Rsa.xcframework/ios-arm64_x86_64-simulator/librsa_bridge.a differ
diff --git a/package.json b/package.json
index fc0560b..f236815 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-fast-rsa",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "description": "library for use RSA",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -164,9 +164,8 @@
     ]
   },
   "dependencies": {
-    "big-integer": "^1.6.51",
-    "flatbuffers": "24.3.25",
-    "text-encoding-polyfill": "^0.6.7"
+    "big-integer": "^1.6.52",
+    "flatbuffers": "24.3.25"
   },
   "codegenConfig": {
     "name": "RNFastRsaSpec",
diff --git a/src/index.tsx b/src/index.ts
similarity index 68%
rename from src/index.tsx
rename to src/index.ts
index 0980f34..3b6eead 100644
--- a/src/index.tsx
+++ b/src/index.ts
@@ -22,9 +22,23 @@ import { VerifyPKCS1v15Request } from './model/verify-pkcs1v15-request';
 import { HashRequest } from './model/hash-request';
 import { Base64Request } from './model/base64-request';
 import { PKCS12KeyPairResponse } from './model/pkcs12-key-pair-response';
+import { BytesResponse } from './model/bytes-response';
 import './shim';
+import { DecryptOAEPBytesRequest } from './model/decrypt-oaepbytes-request';
+import { DecryptPKCS1v15BytesRequest } from './model/decrypt-pkcs1v15-bytes-request';
+import { EncryptOAEPBytesRequest } from './model/encrypt-oaepbytes-request';
+import { EncryptPKCS1v15BytesRequest } from './model/encrypt-pkcs1v15-bytes-request';
+import { SignPSSBytesRequest } from './model/sign-pssbytes-request';
+import { SignPKCS1v15BytesRequest } from './model/sign-pkcs1v15-bytes-request';
+import { VerifyPSSBytesRequest } from './model/verify-pssbytes-request';
+import { VerifyPKCS1v15BytesRequest } from './model/verify-pkcs1v15-bytes-request';
 
 const FastRSANativeModules = (NativeModules as NativeModulesDef).FastRsa;
+const isDebuggingEnabled = typeof atob !== 'undefined';
+
+typeof global.FastRSACallPromise === 'undefined' &&
+  !isDebuggingEnabled &&
+  FastRSANativeModules.install();
 
 export interface PCKS12KeyPair {
   publicKey: string;
@@ -58,14 +72,15 @@ export enum SaltLength {
   EQUALS_HASH = 1,
 }
 
-export default class RSA {
-  /**
-   * for now we recommend use this in false because is sync
-   */
-  static useJSI = false;
+class RSAError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'RSAError';
+  }
+}
 
-  private static loaded = false;
-  private static TAG = '[FastRSA]';
+export default class RSA {
+  static useJSI = true;
 
   static async convertJWKToPrivateKey(
     data: any,
@@ -341,6 +356,31 @@ export default class RSA {
     const result = await this.call('decryptOAEP', builder.asUint8Array());
     return this._stringResponse(result);
   }
+
+  static async decryptOAEPBytes(
+    message: Uint8Array,
+    label: string,
+    hashName: Hash,
+    privateKey: string
+  ): Promise<Uint8Array> {
+    const builder = new flatbuffers.Builder(0);
+
+    const messageOffset = builder.createByteVector(message);
+    const labelOffset = builder.createString(label);
+    const privateKeyOffset = builder.createString(privateKey);
+
+    DecryptOAEPBytesRequest.startDecryptOAEPBytesRequest(builder);
+    DecryptOAEPBytesRequest.addCiphertext(builder, messageOffset);
+    DecryptOAEPBytesRequest.addLabel(builder, labelOffset);
+    DecryptOAEPBytesRequest.addPrivateKey(builder, privateKeyOffset);
+    DecryptOAEPBytesRequest.addHash(builder, hashName);
+    const offset = DecryptOAEPBytesRequest.endDecryptOAEPBytesRequest(builder);
+    builder.finish(offset);
+
+    const result = await this.call('decryptOAEPBytes', builder.asUint8Array());
+    return this._bytesResponse(result);
+  }
+
   static async decryptPKCS1v15(
     message: string,
     privateKey: string
@@ -359,6 +399,29 @@ export default class RSA {
     const result = await this.call('decryptPKCS1v15', builder.asUint8Array());
     return this._stringResponse(result);
   }
+
+  static async decryptPKCS1v15Bytes(
+    message: Uint8Array,
+    privateKey: string
+  ): Promise<Uint8Array> {
+    const builder = new flatbuffers.Builder(0);
+
+    const messageOffset = builder.createByteVector(message);
+    const privateKeyOffset = builder.createString(privateKey);
+
+    DecryptPKCS1v15BytesRequest.startDecryptPKCS1v15BytesRequest(builder);
+    DecryptPKCS1v15BytesRequest.addPrivateKey(builder, privateKeyOffset);
+    DecryptPKCS1v15BytesRequest.addCiphertext(builder, messageOffset);
+    const offset =
+      DecryptPKCS1v15BytesRequest.endDecryptPKCS1v15BytesRequest(builder);
+    builder.finish(offset);
+
+    const result = await this.call(
+      'decryptPKCS1v15Bytes',
+      builder.asUint8Array()
+    );
+    return this._bytesResponse(result);
+  }
   static async encryptOAEP(
     message: string,
     label: string,
@@ -382,6 +445,29 @@ export default class RSA {
     const result = await this.call('encryptOAEP', builder.asUint8Array());
     return this._stringResponse(result);
   }
+  static async encryptOAEPBytes(
+    message: Uint8Array,
+    label: string,
+    hashName: Hash,
+    publicKey: string
+  ): Promise<Uint8Array> {
+    const builder = new flatbuffers.Builder(0);
+
+    const messageOffset = builder.createByteVector(message);
+    const labelOffset = builder.createString(label);
+    const publicKeyOffset = builder.createString(publicKey);
+
+    EncryptOAEPBytesRequest.startEncryptOAEPBytesRequest(builder);
+    EncryptOAEPBytesRequest.addMessage(builder, messageOffset);
+    EncryptOAEPBytesRequest.addLabel(builder, labelOffset);
+    EncryptOAEPBytesRequest.addHash(builder, hashName);
+    EncryptOAEPBytesRequest.addPublicKey(builder, publicKeyOffset);
+    const offset = EncryptOAEPBytesRequest.endEncryptOAEPBytesRequest(builder);
+    builder.finish(offset);
+
+    const result = await this.call('encryptOAEPBytes', builder.asUint8Array());
+    return this._bytesResponse(result);
+  }
   static async encryptPKCS1v15(
     message: string,
     publicKey: string
@@ -400,6 +486,28 @@ export default class RSA {
     const result = await this.call('encryptPKCS1v15', builder.asUint8Array());
     return this._stringResponse(result);
   }
+  static async encryptPKCS1v15Bytes(
+    message: Uint8Array,
+    publicKey: string
+  ): Promise<Uint8Array> {
+    const builder = new flatbuffers.Builder(0);
+
+    const messageOffset = builder.createByteVector(message);
+    const publicKeyOffset = builder.createString(publicKey);
+
+    EncryptPKCS1v15BytesRequest.startEncryptPKCS1v15BytesRequest(builder);
+    EncryptPKCS1v15BytesRequest.addMessage(builder, messageOffset);
+    EncryptPKCS1v15BytesRequest.addPublicKey(builder, publicKeyOffset);
+    const offset =
+      EncryptPKCS1v15BytesRequest.endEncryptPKCS1v15BytesRequest(builder);
+    builder.finish(offset);
+
+    const result = await this.call(
+      'encryptPKCS1v15Bytes',
+      builder.asUint8Array()
+    );
+    return this._bytesResponse(result);
+  }
   static async signPSS(
     message: string,
     hashName: Hash,
@@ -422,6 +530,28 @@ export default class RSA {
     const result = await this.call('signPSS', builder.asUint8Array());
     return this._stringResponse(result);
   }
+  static async signPSSBytes(
+    message: Uint8Array,
+    hashName: Hash,
+    saltLengthName: SaltLength,
+    privateKey: string
+  ): Promise<Uint8Array> {
+    const builder = new flatbuffers.Builder(0);
+
+    const messageOffset = builder.createByteVector(message);
+    const privateKeyOffset = builder.createString(privateKey);
+
+    SignPSSBytesRequest.startSignPSSBytesRequest(builder);
+    SignPSSBytesRequest.addMessage(builder, messageOffset);
+    SignPSSBytesRequest.addHash(builder, hashName);
+    SignPSSBytesRequest.addSaltLength(builder, saltLengthName);
+    SignPSSBytesRequest.addPrivateKey(builder, privateKeyOffset);
+    const offset = SignPSSBytesRequest.endSignPSSBytesRequest(builder);
+    builder.finish(offset);
+
+    const result = await this.call('signPSSBytes', builder.asUint8Array());
+    return this._bytesResponse(result);
+  }
   static async signPKCS1v15(
     message: string,
     hashName: Hash,
@@ -442,6 +572,27 @@ export default class RSA {
     const result = await this.call('signPKCS1v15', builder.asUint8Array());
     return this._stringResponse(result);
   }
+  static async signPKCS1v15Bytes(
+    message: Uint8Array,
+    hashName: Hash,
+    privateKey: string
+  ): Promise<Uint8Array> {
+    const builder = new flatbuffers.Builder(0);
+
+    const messageOffset = builder.createByteVector(message);
+    const privateKeyOffset = builder.createString(privateKey);
+
+    SignPKCS1v15BytesRequest.startSignPKCS1v15BytesRequest(builder);
+    SignPKCS1v15BytesRequest.addMessage(builder, messageOffset);
+    SignPKCS1v15BytesRequest.addHash(builder, hashName);
+    SignPKCS1v15BytesRequest.addPrivateKey(builder, privateKeyOffset);
+    const offset =
+      SignPKCS1v15BytesRequest.endSignPKCS1v15BytesRequest(builder);
+    builder.finish(offset);
+
+    const result = await this.call('signPKCS1v15Bytes', builder.asUint8Array());
+    return this._bytesResponse(result);
+  }
   static async verifyPSS(
     signature: string,
     message: string,
@@ -467,6 +618,31 @@ export default class RSA {
     const result = await this.call('verifyPSS', builder.asUint8Array());
     return this._boolResponse(result);
   }
+  static async verifyPSSBytes(
+    signature: Uint8Array,
+    message: Uint8Array,
+    hashName: Hash,
+    saltLengthName: SaltLength,
+    publicKey: string
+  ): Promise<boolean> {
+    const builder = new flatbuffers.Builder(0);
+
+    const signatureOffset = builder.createByteVector(signature);
+    const messageOffset = builder.createByteVector(message);
+    const publicKeyOffset = builder.createString(publicKey);
+
+    VerifyPSSBytesRequest.startVerifyPSSBytesRequest(builder);
+    VerifyPSSBytesRequest.addSignature(builder, signatureOffset);
+    VerifyPSSBytesRequest.addMessage(builder, messageOffset);
+    VerifyPSSBytesRequest.addHash(builder, hashName);
+    VerifyPSSBytesRequest.addSaltLength(builder, saltLengthName);
+    VerifyPSSBytesRequest.addPublicKey(builder, publicKeyOffset);
+    const offset = VerifyPSSBytesRequest.endVerifyPSSBytesRequest(builder);
+    builder.finish(offset);
+
+    const result = await this.call('verifyPSSBytes', builder.asUint8Array());
+    return this._boolResponse(result);
+  }
   static async verifyPKCS1v15(
     signature: string,
     message: string,
@@ -490,6 +666,33 @@ export default class RSA {
     const result = await this.call('verifyPKCS1v15', builder.asUint8Array());
     return this._boolResponse(result);
   }
+  static async verifyPKCS1v15Bytes(
+    signature: Uint8Array,
+    message: Uint8Array,
+    hashName: Hash,
+    publicKey: string
+  ): Promise<boolean> {
+    const builder = new flatbuffers.Builder(0);
+
+    const signatureOffset = builder.createByteVector(signature);
+    const messageOffset = builder.createByteVector(message);
+    const publicKeyOffset = builder.createString(publicKey);
+
+    VerifyPKCS1v15BytesRequest.startVerifyPKCS1v15BytesRequest(builder);
+    VerifyPKCS1v15BytesRequest.addSignature(builder, signatureOffset);
+    VerifyPKCS1v15BytesRequest.addMessage(builder, messageOffset);
+    VerifyPKCS1v15BytesRequest.addHash(builder, hashName);
+    VerifyPKCS1v15BytesRequest.addPublicKey(builder, publicKeyOffset);
+    const offset =
+      VerifyPKCS1v15BytesRequest.endVerifyPKCS1v15BytesRequest(builder);
+    builder.finish(offset);
+
+    const result = await this.call(
+      'verifyPKCS1v15Bytes',
+      builder.asUint8Array()
+    );
+    return this._boolResponse(result);
+  }
 
   static async hash(message: string, name: Hash): Promise<string> {
     const builder = new flatbuffers.Builder(0);
@@ -537,66 +740,39 @@ export default class RSA {
     bytes: Uint8Array
   ): Promise<flatbuffers.ByteBuffer> {
     try {
-      let result: BridgeResponse;
-      if (this.useJSI) {
-        if (!this.loaded) {
-          this.loaded = FastRSANativeModules.install();
-          console.log(
-            this.TAG,
-            `(${name})`,
-            'JSI install:',
-            this.loaded ? 'Installed' : 'Not Installed'
-          );
-        }
-        if (this.loaded) {
-          const buff = bytes.buffer.slice(
-            bytes.byteOffset,
-            bytes.byteLength + bytes.byteOffset
-          );
-
-          result = await global.FastRSACallPromise(name, buff);
-          if (typeof result === 'string') {
-            throw new Error(result);
-          }
-        } else {
-          console.log(
-            this.TAG,
-            `(${name})`,
-            'cant use JSI in debug mode, fallback to NativeModules'
-          );
-          result = await FastRSANativeModules.call(name, Array.from(bytes));
-        }
+      if (this.useJSI && typeof global.FastRSACallPromise === 'function') {
+        const buff = bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteLength + bytes.byteOffset
+        );
+
+        const result = global.FastRSACallSync(name, buff);
+        const rawResponse = new Uint8Array(result, 0, result.byteLength);
+        return new flatbuffers.ByteBuffer(rawResponse);
       } else {
-        result = await FastRSANativeModules.call(name, Array.from(bytes));
+        const result = await FastRSANativeModules.call(name, Array.from(bytes));
+        const rawResponse = new Uint8Array(result);
+        return new flatbuffers.ByteBuffer(rawResponse);
       }
-
-      return this._responseBuffer(result);
     } catch (e) {
-      throw e;
+      throw new RSAError(`BridgeCall failed: ${e}`);
     }
   }
 
-  private static _responseBuffer(result: BridgeResponse) {
-    if (!result) {
-      throw new Error('empty result');
-    }
-    var rawResponse;
-    if (result.hasOwnProperty('length')) {
-      const resultArray = result as BridgeResponseNativeModules;
-      rawResponse = new Uint8Array(resultArray);
-    } else {
-      const resultBytes = result as BridgeResponseJSI as ArrayBuffer;
-      rawResponse = new Uint8Array(resultBytes, 0, resultBytes.byteLength);
+  private static _bytesResponse(result: flatbuffers.ByteBuffer): Uint8Array {
+    const response = BytesResponse.getRootAsBytesResponse(result);
+    const error = response.error();
+    if (error) {
+      throw new RSAError('stringResponse: ' + error);
     }
-
-    return new flatbuffers.ByteBuffer(rawResponse);
+    return response.outputArray() || Uint8Array.from([]);
   }
 
   private static _stringResponse(result: flatbuffers.ByteBuffer): string {
     const response = StringResponse.getRootAsStringResponse(result);
     const error = response.error();
     if (error) {
-      throw new Error('stringResponse: ' + error);
+      throw new RSAError('stringResponse: ' + error);
     }
     return response.output() || '';
   }
@@ -605,7 +781,7 @@ export default class RSA {
     const response = BoolResponse.getRootAsBoolResponse(result);
     const error = response.error();
     if (error) {
-      throw new Error('boolResponse: ' + error);
+      throw new RSAError('boolResponse: ' + error);
     }
     return response.output();
   }
@@ -614,11 +790,11 @@ export default class RSA {
     const response = KeyPairResponse.getRootAsKeyPairResponse(result);
     const error = response.error();
     if (error) {
-      throw new Error('keyPairResponse: ' + error);
+      throw new RSAError('keyPairResponse: ' + error);
     }
     const output = response.output();
     if (!output) {
-      throw new Error('empty output');
+      throw new RSAError('empty output');
     }
 
     return {
@@ -634,11 +810,11 @@ export default class RSA {
       PKCS12KeyPairResponse.getRootAsPKCS12KeyPairResponse(result);
     const error = response.error();
     if (error) {
-      throw new Error('pkcs12KeyPairResponse: ' + error);
+      throw new RSAError('pkcs12KeyPairResponse: ' + error);
     }
     const output = response.output();
     if (!output) {
-      throw new Error('empty output');
+      throw new RSAError('empty output');
     }
 
     return {
diff --git a/src/shim.ts b/src/shim.ts
index e9241eb..6df0c7f 100644
--- a/src/shim.ts
+++ b/src/shim.ts
@@ -1,28 +1,14 @@
-if (typeof global.TextEncoder === 'undefined') {
-  require('text-encoding-polyfill');
+if (typeof global.BigInt === 'undefined') {
+  const BigInt = require('./utils/big-int').default;
+  global.BigInt = BigInt;
 }
 
-if (typeof global.BigInt === 'undefined') {
-  const bigInt = require('big-integer');
-  bigInt.asUintN = function (bits: any, bigint: any) {
-    bigint = bigInt(bigint);
-    if (typeof bigint.value === 'bigint') {
-      return bigInt(BigInt.asUintN(bits, bigint.value));
-    }
-    const p2bits = bigInt(1).shiftLeft(bits);
-    const mod = bigint.and(p2bits.subtract(1));
-    return mod;
-  };
-  bigInt.asIntN = function (bits: any, bigint: any) {
-    bigint = bigInt(bigint);
-    if (typeof bigint.value === 'bigint') {
-      return bigInt(BigInt.asIntN(bits, bigint.value));
-    }
-    const p2bits = bigInt(1).shiftLeft(bits);
-    const mod = bigint.and(p2bits.subtract(1));
-    return mod.greaterOrEquals(p2bits.subtract(mod))
-      ? mod.subtract(p2bits)
-      : mod;
-  };
-  global.BigInt = bigInt;
+if (typeof global.TextDecoder === 'undefined') {
+  const TextDecoder = require('./utils/text-decoder').default;
+  global.TextDecoder = TextDecoder;
+}
+
+if (typeof global.TextEncoder === 'undefined') {
+  const TextEncoder = require('./utils/text-encoder').default;
+  global.TextEncoder = TextEncoder;
 }
diff --git a/src/types.d.ts b/src/types.d.ts
index c16bdbc..319d2b8 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -1,27 +1,3 @@
-/**
- * `Array`: returned by NativeModules due to lack of ByteArray support
- *
- * @see `FastRSANativeModules.call`
- */
-type BridgeResponseNativeModules = Array<number>;
-
-/**
- * `ArrayBuffer`: returned only by pure JSI implementation
- * `String`: returned only by pure JSI implementation, maybe we can inprove this in the future
- *
- * @see `FastRSAJSI.callPromise`
- * @see `FastRSAJSI.callSync`
- */
-type BridgeResponseJSI = ArrayBuffer | string;
-
-/**
- * Combination of all available types
- *
- * @see `BridgeResponseNativeModules`
- * @see `BridgeResponseJSI`
- */
-type BridgeResponse = BridgeResponseNativeModules | BridgeResponseJSI;
-
 /**
  * Contains all method available inside of `NativeModules`
  */
@@ -30,10 +6,16 @@ interface FastRSANativeModules {
    * this method use `NativeModules` in a more traditional way
    * using `JNI` on android in order to call shared a library.
    */
-  call(
-    name: string,
-    payload: Array<number>
-  ): Promise<BridgeResponseNativeModules>;
+  call(name: string, payload: number[]): Promise<number[]>;
+
+  encodeText(input: string, encoding: string): number[];
+  decodeText(
+    input: number[],
+    encoding: string,
+    fatal: boolean,
+    ignoreBOM: boolean,
+    stream: boolean
+  ): string;
   /**
    * this method will install JSI definitions
    */
@@ -47,6 +29,7 @@ interface NativeModulesDef {
 interface Global {
   BigInt: any;
   TextEncoder: any;
+  TextDecoder: any;
   // for now we are not going to use this way because of hermes on release mode only
   // FastRSA:FastRSAJSI
   /**
@@ -56,14 +39,27 @@ interface Global {
    */
   FastRSACallPromise(
     name: string,
-    payload: ArrayBuffer
-  ): Promise<BridgeResponseJSI>;
+    payload: ArrayBuffer | SharedArrayBuffer
+  ): Promise<ArrayBuffer>;
   /**
    * this method use `JSI`, and will use in a Sync way,
    * be careful if the method that you are using is a complex one like generate a new Key
    */
-  FastRSACallSync(name: string, payload: ArrayBuffer): BridgeResponseJSI;
+  FastRSACallSync(
+    name: string,
+    payload: ArrayBuffer | SharedArrayBuffer
+  ): ArrayBuffer;
+
+  FastRSAEncodeText(input: string, encoding: string): Uint8Array;
+  FastRSADecodeText(
+    input: Uint8Array,
+    encoding: string,
+    fatal: boolean,
+    ignoreBOM: boolean,
+    stream: boolean
+  ): string;
 }
 
 declare const global: Global;
 declare const module: any;
+declare const atob: any;
diff --git a/src/utils/big-int.ts b/src/utils/big-int.ts
new file mode 100644
index 0000000..551bd1f
--- /dev/null
+++ b/src/utils/big-int.ts
@@ -0,0 +1,21 @@
+const BigInt = require('big-integer');
+BigInt.asUintN = function (bits: any, bigint: any) {
+  bigint = BigInt(bigint);
+  if (typeof bigint.value === 'bigint') {
+    return BigInt(BigInt.asUintN(bits, bigint.value));
+  }
+  const p2bits = BigInt(1).shiftLeft(bits);
+  const mod = bigint.and(p2bits.subtract(1));
+  return mod;
+};
+BigInt.asIntN = function (bits: any, bigint: any) {
+  bigint = BigInt(bigint);
+  if (typeof bigint.value === 'bigint') {
+    return BigInt(BigInt.asIntN(bits, bigint.value));
+  }
+  const p2bits = BigInt(1).shiftLeft(bits);
+  const mod = bigint.and(p2bits.subtract(1));
+  return mod.greaterOrEquals(p2bits.subtract(mod)) ? mod.subtract(p2bits) : mod;
+};
+
+export default BigInt;
diff --git a/src/utils/text-decoder.ts b/src/utils/text-decoder.ts
new file mode 100644
index 0000000..83e13e6
--- /dev/null
+++ b/src/utils/text-decoder.ts
@@ -0,0 +1,53 @@
+import { NativeModules } from 'react-native';
+
+const FastRSANativeModules = (NativeModules as NativeModulesDef).FastRsa;
+const isDebuggingEnabled = typeof atob !== 'undefined';
+
+typeof global.FastRSADecodeText === 'undefined' &&
+  !isDebuggingEnabled &&
+  FastRSANativeModules.install();
+
+interface TextDecoderOptions {
+  fatal?: boolean;
+  ignoreBOM?: boolean;
+}
+
+interface TextDecodeOptions {
+  stream?: boolean;
+}
+
+export default class TextDecoder {
+  private encoding: string;
+  private fatal: boolean;
+  private ignoreBOM: boolean;
+
+  constructor(label: string = 'utf-8', options: TextDecoderOptions = {}) {
+    this.encoding = label.toLowerCase();
+    this.fatal = options.fatal ?? false;
+    this.ignoreBOM = options.ignoreBOM ?? false;
+  }
+
+  decode(input?: Uint8Array, options: TextDecodeOptions = {}): string {
+    if (!input) {
+      return '';
+    }
+
+    if (typeof global.FastRSADecodeText === 'function') {
+      const ress = global.FastRSADecodeText(
+        input,
+        this.encoding,
+        this.fatal,
+        this.ignoreBOM,
+        options.stream ?? false
+      );
+      return ress;
+    }
+    return FastRSANativeModules.decodeText(
+      Array.from(input),
+      this.encoding,
+      this.fatal,
+      this.ignoreBOM,
+      options.stream ?? false
+    );
+  }
+}
diff --git a/src/utils/text-encoder.ts b/src/utils/text-encoder.ts
new file mode 100644
index 0000000..d4d3c91
--- /dev/null
+++ b/src/utils/text-encoder.ts
@@ -0,0 +1,23 @@
+import { NativeModules } from 'react-native';
+
+const FastRSANativeModules = (NativeModules as NativeModulesDef).FastRsa;
+const isDebuggingEnabled = typeof atob !== 'undefined';
+
+typeof global.FastRSAEncodeText === 'undefined' &&
+  !isDebuggingEnabled &&
+  FastRSANativeModules.install();
+
+export default class TextEncoder {
+  get encoding(): string {
+    return 'utf-8';
+  }
+
+  encode(input: string = ''): Uint8Array {
+    if (typeof global.FastRSAEncodeText === 'function') {
+      const result = global.FastRSAEncodeText(input, 'utf-8');
+      return new Uint8Array(result);
+    }
+    const result = FastRSANativeModules.encodeText(input, 'utf-8');
+    return new Uint8Array(result);
+  }
+}
diff --git a/yarn.lock b/yarn.lock
index b68eace..b5d1b61 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5055,10 +5055,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"big-integer@npm:^1.6.51":
-  version: 1.6.51
-  resolution: "big-integer@npm:1.6.51"
-  checksum: 3d444173d1b2e20747e2c175568bedeebd8315b0637ea95d75fd27830d3b8e8ba36c6af40374f36bdaea7b5de376dcada1b07587cb2a79a928fccdb6e6e3c518
+"big-integer@npm:^1.6.52":
+  version: 1.6.52
+  resolution: "big-integer@npm:1.6.52"
+  checksum: 6e86885787a20fed96521958ae9086960e4e4b5e74d04f3ef7513d4d0ad631a9f3bde2730fc8aaa4b00419fc865f6ec573e5320234531ef37505da7da192c40b
   languageName: node
   linkType: hard
 
@@ -13166,7 +13166,7 @@ __metadata:
     "@types/jest": ^28.1.2
     "@types/react": ~17.0.21
     "@types/react-native": 0.70.0
-    big-integer: ^1.6.51
+    big-integer: ^1.6.52
     commitlint: ^17.0.2
     del-cli: ^5.0.0
     eslint: ^8.4.1
@@ -13180,7 +13180,6 @@ __metadata:
     react-native: 0.72.6
     react-native-builder-bob: ^0.20.0
     release-it: ^15.0.0
-    text-encoding-polyfill: ^0.6.7
     turbo: ^1.10.7
     typescript: ^5.0.2
   peerDependencies:
@@ -14878,13 +14877,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"text-encoding-polyfill@npm:^0.6.7":
-  version: 0.6.7
-  resolution: "text-encoding-polyfill@npm:0.6.7"
-  checksum: 8e5b45154f3394cd29af01760ec2f728caba7cfc57fbcab60c073dc9c6db479d923efda3e074ae467379c4a0710c45e6427c6917a70da3059876924c190e03ed
-  languageName: node
-  linkType: hard
-
 "text-extensions@npm:^1.0.0":
   version: 1.9.0
   resolution: "text-extensions@npm:1.9.0"