edhoc 1.2.3 → 1.3.0

package/src/EdhocEadManager.cpp

@@ -5,7 +5,7 @@
 #include <iostream>
 #include <stdexcept>
 
-#include "UserContext.h"
+#include "RunningContext.h"
 #include "Utils.h"
 
 static constexpr const char* kErrorExpectedObject = "Expected an object as element in the input array";
@@ -21,11 +21,11 @@ EdhocEadManager::EdhocEadManager() {
 }
 
 EdhocEadManager::~EdhocEadManager() {
-  eadBuffers.clear();
+  eadBuffers_.clear();
 }
 
 void EdhocEadManager::StoreEad(enum edhoc_message message, int label, const std::vector<uint8_t>& ead) {
-  auto& vecOfMaps = eadBuffers[message];
+  auto& vecOfMaps = eadBuffers_[message];
   EadMap newMap;
   newMap[label] = ead;
   vecOfMaps.push_back(std::move(newMap));
@@ -36,7 +36,7 @@ void EdhocEadManager::StoreEad(enum edhoc_message message, const Napi::Array& ea
   for (size_t i = 0; i < eadArray.Length(); i++) {
     Napi::Value element = eadArray.Get(i);
     if (!element.IsObject()) {
-      Napi::TypeError::New(env, kErrorExpectedObject).ThrowAsJavaScriptException();
+      throw Napi::TypeError::New(env, kErrorExpectedObject);
     }
 
     Napi::Object obj = element.As<Napi::Object>();
@@ -44,7 +44,7 @@ void EdhocEadManager::StoreEad(enum edhoc_message message, const Napi::Array& ea
     Napi::Value bufferValue = obj.Get(kPropValue);
 
     if (!labelValue.IsNumber() || !bufferValue.IsBuffer()) {
-      Napi::TypeError::New(env, kErrorExpectedLabelNumberAndValueBuffer).ThrowAsJavaScriptException();
+      throw Napi::TypeError::New(env, kErrorExpectedLabelNumberAndValueBuffer);
     }
 
     int label = labelValue.As<Napi::Number>().Int32Value();
@@ -56,8 +56,8 @@ void EdhocEadManager::StoreEad(enum edhoc_message message, const Napi::Array& ea
 }
 
 const EadMapVector* EdhocEadManager::GetEadByMessage(enum edhoc_message message) const {
-  auto it = eadBuffers.find(message);
-  return it != eadBuffers.end() ? &it->second : nullptr;
+  auto it = eadBuffers_.find(message);
+  return it != eadBuffers_.end() ? &it->second : nullptr;
 }
 
 Napi::Array EdhocEadManager::GetEadByMessage(Napi::Env& env, enum edhoc_message message) const {
@@ -81,7 +81,7 @@ Napi::Array EdhocEadManager::GetEadByMessage(Napi::Env& env, enum edhoc_message
 }
 
 void EdhocEadManager::ClearEadByMessage(enum edhoc_message message) {
-  eadBuffers.erase(message);
+  eadBuffers_.erase(message);
 }
 
 int EdhocEadManager::ComposeEad(void* user_context,
@@ -89,7 +89,7 @@ int EdhocEadManager::ComposeEad(void* user_context,
                                 struct edhoc_ead_token* ead_token,
                                 size_t ead_token_size,
                                 size_t* ead_token_len) {
-  UserContext* context = static_cast<UserContext*>(user_context);
+  RunningContext* context = static_cast<RunningContext*>(const_cast<void*>(user_context));
   EdhocEadManager* manager = context->GetEadManager();
   return manager->callComposeEad(message, ead_token, ead_token_size, ead_token_len);
 }
@@ -98,7 +98,7 @@ int EdhocEadManager::ProcessEad(void* user_context,
                                 enum edhoc_message message,
                                 const struct edhoc_ead_token* ead_token,
                                 size_t ead_token_size) {
-  UserContext* context = static_cast<UserContext*>(user_context);
+  RunningContext* context = static_cast<RunningContext*>(const_cast<void*>(user_context));
   EdhocEadManager* manager = context->GetEadManager();
   return manager->callProcessEad(message, ead_token, ead_token_size);
 }
@@ -107,15 +107,15 @@ int EdhocEadManager::callComposeEad(enum edhoc_message message,
                                     struct edhoc_ead_token* ead_token,
                                     size_t ead_token_size,
                                     size_t* ead_token_len) {
-  const EadMapVector* eadBuffers = GetEadByMessage(message);
-  if (!eadBuffers) {
+  const EadMapVector* eadBuffers_ = GetEadByMessage(message);
+  if (!eadBuffers_) {
     *ead_token_len = 0;
     return EDHOC_SUCCESS;
   }
 
   size_t count = 0;
 
-  for (const auto& map : *eadBuffers) {
+  for (const auto& map : *eadBuffers_) {
     for (const auto& [label, buffer] : map) {
       if (count >= ead_token_size) {
         break;

package/src/EdhocExportOscoreAsyncWorker.cpp

@@ -10,34 +10,35 @@ static constexpr size_t kMasterSecrectSize = 16;
 static constexpr size_t kMasterSaltSize = 8;
 static constexpr size_t kConnectionIdSize = 7;
 
-EdhocExportOscoreAsyncWorker::EdhocExportOscoreAsyncWorker(Napi::Env& env,
-                                                           struct edhoc_context& context,
-                                                           CallbackType callback)
-    : Napi::AsyncWorker(env),
-      deferred(Napi::Promise::Deferred::New(env)),
-      context(context),
-      masterSecret(kMasterSecrectSize),
-      masterSalt(kMasterSaltSize),
-      senderId(kConnectionIdSize),
-      recipientId(kConnectionIdSize),
-      callback(std::move(callback)) {}
+EdhocExportOscoreAsyncWorker::EdhocExportOscoreAsyncWorker(RunningContext* runningContext)
+    : Napi::AsyncWorker(runningContext->GetEnv()),
+      runningContext_(runningContext),
+      masterSecret_(kMasterSecrectSize),
+      masterSalt_(kMasterSaltSize),
+      senderId_(kConnectionIdSize),
+      recipientId_(kConnectionIdSize) {}
 
 EdhocExportOscoreAsyncWorker::~EdhocExportOscoreAsyncWorker() {}
 
 void EdhocExportOscoreAsyncWorker::Execute() {
-  size_t sender_id_length, recipient_id_length;
+  try {
+    size_t sender_id_length, recipient_id_length;
 
-  int ret = edhoc_export_oscore_session(&context, masterSecret.data(), masterSecret.size(), masterSalt.data(),
-                                        masterSalt.size(), senderId.data(), senderId.size(), &sender_id_length,
-                                        recipientId.data(), recipientId.size(), &recipient_id_length);
+    int ret = edhoc_export_oscore_session(runningContext_->GetEdhocContext(), masterSecret_.data(), masterSecret_.size(), masterSalt_.data(),
+                                          masterSalt_.size(), senderId_.data(), senderId_.size(), &sender_id_length,
+                                          recipientId_.data(), recipientId_.size(), &recipient_id_length);
 
-  if (ret != EDHOC_SUCCESS) {
-    char errorMessage[kErrorBufferSize];
-    std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, ret);
-    SetError(errorMessage);
-  } else {
-    senderId.resize(sender_id_length);
-    recipientId.resize(recipient_id_length);
+    if (ret != EDHOC_SUCCESS) {
+      char errorMessage[kErrorBufferSize];
+      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, ret);
+      SetError(errorMessage);
+    } else {
+      senderId_.resize(sender_id_length);
+      recipientId_.resize(recipient_id_length);
+    }
+
+  } catch (const std::exception& e) {
+    SetError(e.what());
   }
 }
 
@@ -45,10 +46,10 @@ void EdhocExportOscoreAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
 
-  auto masterSecretBuffer = Napi::Buffer<uint8_t>::Copy(env, masterSecret.data(), masterSecret.size());
-  auto masterSaltBuffer = Napi::Buffer<uint8_t>::Copy(env, masterSalt.data(), masterSalt.size());
-  auto senderIdBuffer = Napi::Buffer<uint8_t>::Copy(env, senderId.data(), senderId.size());
-  auto recipientIdBuffer = Napi::Buffer<uint8_t>::Copy(env, recipientId.data(), recipientId.size());
+  auto masterSecretBuffer = Napi::Buffer<uint8_t>::Copy(env, masterSecret_.data(), masterSecret_.size());
+  auto masterSaltBuffer = Napi::Buffer<uint8_t>::Copy(env, masterSalt_.data(), masterSalt_.size());
+  auto senderIdBuffer = Napi::Buffer<uint8_t>::Copy(env, senderId_.data(), senderId_.size());
+  auto recipientIdBuffer = Napi::Buffer<uint8_t>::Copy(env, recipientId_.data(), recipientId_.size());
 
   Napi::Object resultObj = Napi::Object::New(env);
   resultObj.Set(kPropMasterSecret, masterSecretBuffer);
@@ -56,28 +57,11 @@ void EdhocExportOscoreAsyncWorker::OnOK() {
   resultObj.Set(kPropSenderId, senderIdBuffer);
   resultObj.Set(kPropRecipientId, recipientIdBuffer);
 
-  callback(env);
-
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Resolve(resultObj);
-  }
+  runningContext_->Resolve(resultObj);
 }
 
 void EdhocExportOscoreAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-
-  callback(env);
-
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Reject(error.Value());
-  }
-}
-
-Napi::Promise EdhocExportOscoreAsyncWorker::GetPromise() {
-  return deferred.Promise();
+  runningContext_->Reject(error.Value());
 }

package/src/EdhocKeyExporterAsyncWorker.cpp

@@ -3,55 +3,37 @@
 static constexpr const char* kErrorMessageFormat = "Failed to export the key. Error code: %d.";
 static constexpr size_t kErrorBufferSize = 100;
 
-EdhocKeyExporterAsyncWorker::EdhocKeyExporterAsyncWorker(Napi::Env& env,
-                                                         struct edhoc_context& context,
+EdhocKeyExporterAsyncWorker::EdhocKeyExporterAsyncWorker(RunningContext* runningContext,
                                                          uint16_t label,
-                                                         uint8_t desiredLength,
-                                                         CallbackType callback)
-    : Napi::AsyncWorker(env),
-      deferred(Napi::Promise::Deferred::New(env)),
-      context(context),
-      label(label),
-      desiredLength(desiredLength),
-      output(desiredLength),
-      callback(std::move(callback)) {}
+                                                         uint8_t desiredLength)
+    : Napi::AsyncWorker(runningContext->GetEnv()),
+      runningContext_(runningContext),
+      label_(label),
+      desiredLength_(desiredLength),
+      output_(desiredLength) {}
 
 void EdhocKeyExporterAsyncWorker::Execute() {
-  int ret = edhoc_export_prk_exporter(&context, label, output.data(), desiredLength);
-  if (ret != EDHOC_SUCCESS) {
-    char errorMessage[kErrorBufferSize];
-    std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, ret);
-    SetError(errorMessage);
+  try {
+    int ret = edhoc_export_prk_exporter(runningContext_->GetEdhocContext(), label_, output_.data(), desiredLength_);
+    if (ret != EDHOC_SUCCESS) {
+      char errorMessage[kErrorBufferSize];
+      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, ret);
+      SetError(errorMessage);
+    }
+  } catch (const std::exception& e) {
+    SetError(e.what());
   }
 }
 
 void EdhocKeyExporterAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  auto outputBuffer = Napi::Buffer<uint8_t>::Copy(env, output.data(), output.size());
-
-  callback(env);
-
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Resolve(outputBuffer);
-  }
+  auto outputBuffer = Napi::Buffer<uint8_t>::Copy(env, output_.data(), output_.size());
+  runningContext_->Resolve(outputBuffer);
 }
 
 void EdhocKeyExporterAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-
-  callback(env);
-
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Reject(error.Value());
-  }
-}
-
-Napi::Promise EdhocKeyExporterAsyncWorker::GetPromise() {
-  return deferred.Promise();
+  runningContext_->Reject(error.Value());
 }

package/src/EdhocKeyUpdateAsyncWorker.cpp

@@ -1,49 +1,31 @@
 #include "EdhocKeyUpdateAsyncWorker.h"
 
-EdhocKeyUpdateAsyncWorker::EdhocKeyUpdateAsyncWorker(Napi::Env& env,
-                                                     struct edhoc_context& context,
-                                                     std::vector<uint8_t> contextBuffer,
-                                                     CallbackType callback)
-    : Napi::AsyncWorker(env),
-      deferred(Napi::Promise::Deferred::New(env)),
-      context(context),
-      contextBuffer(contextBuffer),
-      callback(std::move(callback)) {}
+EdhocKeyUpdateAsyncWorker::EdhocKeyUpdateAsyncWorker(RunningContext* runningContext,
+                                                     std::vector<uint8_t> contextBuffer)
+    : Napi::AsyncWorker(runningContext->GetEnv()),
+      runningContext_(runningContext),
+      contextBuffer_(contextBuffer) {}
 
 void EdhocKeyUpdateAsyncWorker::Execute() {
-  int ret = edhoc_export_key_update(&context, contextBuffer.data(), contextBuffer.size());
-
-  if (ret != EDHOC_SUCCESS) {
-    SetError("Failed to update key.");
+  try {
+    int ret = edhoc_export_key_update(runningContext_->GetEdhocContext(), contextBuffer_.data(), contextBuffer_.size());
+
+    if (ret != EDHOC_SUCCESS) {
+      SetError("Failed to update key.");
+    }
+  } catch (const std::exception& e) {
+    SetError(e.what());
   }
 }
 
 void EdhocKeyUpdateAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-
-  callback(env);
-
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Resolve(env.Undefined());
-  }
+  runningContext_->Resolve(env.Undefined());
 }
 
 void EdhocKeyUpdateAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-
-  callback(env);
-
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Reject(error.Value());
-  }
-}
-
-Napi::Promise EdhocKeyUpdateAsyncWorker::GetPromise() {
-  return deferred.Promise();
+  runningContext_->Reject(error.Value());
 }

package/src/EdhocProcessAsyncWorker.cpp

@@ -1,134 +1,120 @@
 #include "EdhocProcessAsyncWorker.h"
 
-#include <iostream>
 static constexpr const char* kErrorInvalidMessageNumber = "Invalid message number";
 static constexpr const char* kErrorMessageFormat = "Failed to process EDHOC message %d. Error code: %d";
 static constexpr const char* kErrorWrongSelectedCipherSuiteFormat =
     "Wrong selected cipher suite. Supported: %s, Received: %s";
 static constexpr size_t kErrorBufferSize = 100;
 
-EdhocProcessAsyncWorker::EdhocProcessAsyncWorker(Napi::Env& env,
-                                                 struct edhoc_context& context,
+EdhocProcessAsyncWorker::EdhocProcessAsyncWorker(RunningContext* runningContext,
                                                  int messageNumber,
-                                                 Napi::Buffer<uint8_t> buffer,
-                                                 CallbackType callback)
-    : Napi::AsyncWorker(env),
-      deferred(Napi::Promise::Deferred::New(env)),
-      context(context),
-      messageNumber(messageNumber),
-      messageBuffer(buffer.Data(), buffer.Data() + buffer.Length()),
-      callback(std::move(callback)),
-      peerCipherSuites() {}
+                                                 Napi::Buffer<uint8_t> buffer)
+    : Napi::AsyncWorker(runningContext->GetEnv()),
+      runningContext_(runningContext),
+      messageNumber_(messageNumber),
+      messageBuffer_(buffer.Data(), buffer.Data() + buffer.Length()),
+      peerCipherSuites_() {}
 
 void EdhocProcessAsyncWorker::Execute() {
-  uint8_t* message = messageBuffer.data();
-  size_t message_length = messageBuffer.size();
-
-  int ret = EDHOC_ERROR_GENERIC_ERROR;
-  switch (messageNumber) {
-    case EDHOC_MSG_1:
-      ret = edhoc_message_1_process(&context, message, message_length);
-      break;
-    case EDHOC_MSG_2:
-      ret = edhoc_message_2_process(&context, message, message_length);
-      break;
-    case EDHOC_MSG_3:
-      ret = edhoc_message_3_process(&context, message, message_length);
-      break;
-    case EDHOC_MSG_4:
-      ret = edhoc_message_4_process(&context, message, message_length);
-      break;
-    default:
-      SetError(kErrorInvalidMessageNumber);
-      return;
-  }
+  try {
+    uint8_t* message = messageBuffer_.data();
+    size_t message_length = messageBuffer_.size();
+
+    int ret = EDHOC_ERROR_GENERIC_ERROR;
+    switch (messageNumber_) {
+      case EDHOC_MSG_1:
+        ret = edhoc_message_1_process(runningContext_->GetEdhocContext(), message, message_length);
+        break;
+      case EDHOC_MSG_2:
+        ret = edhoc_message_2_process(runningContext_->GetEdhocContext(), message, message_length);
+        break;
+      case EDHOC_MSG_3:
+        ret = edhoc_message_3_process(runningContext_->GetEdhocContext(), message, message_length);
+        break;
+      case EDHOC_MSG_4:
+        ret = edhoc_message_4_process(runningContext_->GetEdhocContext(), message, message_length);
+        break;
+      default:
+        SetError(kErrorInvalidMessageNumber);
+        return;
+    }
 
-  if (ret != EDHOC_SUCCESS) {
-    enum edhoc_error_code error_code = EDHOC_ERROR_CODE_SUCCESS;
-    ret = edhoc_error_get_code(&context, &error_code);
-    switch (error_code) {
-      case EDHOC_ERROR_CODE_WRONG_SELECTED_CIPHER_SUITE: {
-        size_t csuites_len = 0;
-        int32_t csuites[10] = {0};
-        size_t peer_csuites_len = 0;
-        int32_t peer_csuites[10] = {0};
-
-        ret = edhoc_error_get_cipher_suites(&context, csuites, ARRAY_SIZE(csuites), &csuites_len, peer_csuites,
-                                            ARRAY_SIZE(peer_csuites), &peer_csuites_len);
-        if (ret == EDHOC_SUCCESS) {
-          std::string suites_str = "[";
-          for (size_t i = 0; i < csuites_len; i++) {
-            suites_str += std::to_string(csuites[i]);
-            if (i < csuites_len - 1) {
-              suites_str += ", ";
+    if (ret != EDHOC_SUCCESS) {
+      enum edhoc_error_code error_code = EDHOC_ERROR_CODE_SUCCESS;
+      ret = edhoc_error_get_code(runningContext_->GetEdhocContext(), &error_code);
+      switch (error_code) {
+        case EDHOC_ERROR_CODE_WRONG_SELECTED_CIPHER_SUITE: {
+          size_t csuites_len = 0;
+          int32_t csuites[10] = {0};
+          size_t peer_csuites_len = 0;
+          int32_t peer_csuites[10] = {0};
+
+          ret = edhoc_error_get_cipher_suites(runningContext_->GetEdhocContext(), csuites, ARRAY_SIZE(csuites), &csuites_len, peer_csuites,
+                                              ARRAY_SIZE(peer_csuites), &peer_csuites_len);
+          if (ret == EDHOC_SUCCESS) {
+            std::string suites_str = "[";
+            for (size_t i = 0; i < csuites_len; i++) {
+              suites_str += std::to_string(csuites[i]);
+              if (i < csuites_len - 1) {
+                suites_str += ", ";
+              }
             }
-          }
-          suites_str += "*]";
-
-          std::string peer_suites_str = "[";
-          for (size_t i = 0; i < peer_csuites_len; i++) {
-            peer_suites_str += std::to_string(peer_csuites[i]);
-            if (i < peer_csuites_len - 1) {
-              peer_suites_str += ", ";
+            suites_str += "*]";
+
+            std::string peer_suites_str = "[";
+            for (size_t i = 0; i < peer_csuites_len; i++) {
+              peer_suites_str += std::to_string(peer_csuites[i]);
+              if (i < peer_csuites_len - 1) {
+                peer_suites_str += ", ";
+              }
             }
-          }
-          peer_suites_str += "*]";
+            peer_suites_str += "*]";
 
-          peerCipherSuites.assign(peer_csuites, peer_csuites + peer_csuites_len);
+            peerCipherSuites_.assign(peer_csuites, peer_csuites + peer_csuites_len);
 
-          char errorMessage[kErrorBufferSize];
-          std::snprintf(errorMessage, kErrorBufferSize, kErrorWrongSelectedCipherSuiteFormat, suites_str.c_str(),
-                        peer_suites_str.c_str());
-          SetError(errorMessage);
-          return;
+            char errorMessage[kErrorBufferSize];
+            std::snprintf(errorMessage, kErrorBufferSize, kErrorWrongSelectedCipherSuiteFormat, suites_str.c_str(),
+                          peer_suites_str.c_str());
+            SetError(errorMessage);
+            return;
+          }
+          break;
         }
-        break;
+        default:
+          break;
       }
-      default:
-        break;
+
+      char errorMessage[kErrorBufferSize];
+      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber_ + 1, error_code);
+      SetError(errorMessage);
     }
 
-    char errorMessage[kErrorBufferSize];
-    std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber + 1, error_code);
-    SetError(errorMessage);
+  } catch (const std::exception& e) {
+    SetError(e.what());
   }
 }
 
 void EdhocProcessAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  Napi::Array result = callback(env);
-
-  callback(env);
+  
+  Napi::Array EADs = runningContext_->GetEadManager()->GetEadByMessage(env, static_cast<enum edhoc_message>(messageNumber_));
+  runningContext_->GetEadManager()->ClearEadByMessage(static_cast<enum edhoc_message>(messageNumber_));
 
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Resolve(result);
-  }
+  runningContext_->Resolve(EADs);
 }
 
 void EdhocProcessAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
 
-  if (peerCipherSuites.size() > 0) {
-    Napi::Array result = Napi::Array::New(env, peerCipherSuites.size());
-    for (size_t i = 0; i < peerCipherSuites.size(); i++) {
-      result.Set(i, Napi::Number::New(env, peerCipherSuites[i]));
+  if (peerCipherSuites_.size() > 0) {
+    Napi::Array result = Napi::Array::New(env, peerCipherSuites_.size());
+    for (size_t i = 0; i < peerCipherSuites_.size(); i++) {
+      result.Set(i, Napi::Number::New(env, peerCipherSuites_[i]));
     }
     error.Set("peerCipherSuites", result);
   }
 
-  callback(env);
-
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Reject(error.Value());
-  }
-}
-
-Napi::Promise EdhocProcessAsyncWorker::GetPromise() {
-  return deferred.Promise();
+  runningContext_->Reject(error.Value());
 }

package/src/RunningContext.cpp

@@ -0,0 +1,95 @@
+#include "RunningContext.h"
+#include <iostream>
+RunningContext::RunningContext(Napi::Env env, 
+                 struct edhoc_context* edhoc_context,
+                 EdhocCryptoManager* cryptoManager,
+                 EdhocEadManager* eadManager,
+                 EdhocCredentialManager* credentialManager,
+                 const Napi::Function& logger) 
+    : edhoc_context_(edhoc_context)
+    , cryptoManager_(cryptoManager)
+    , eadManager_(eadManager)
+    , credentialManager_(credentialManager)
+    , tsfn_()
+    , deferred_(Napi::Promise::Deferred::New(env))
+    , loggerRef_(Napi::Weak(logger))
+    , isResolved_(false)
+{
+    Napi::Function jsCallback = Napi::Function::New(env, [](const Napi::CallbackInfo& info) { return Napi::Value(); });
+    this->tsfn_ = Napi::ThreadSafeFunction::New(env, jsCallback, "jsCallback", 0, 1, this);
+}
+
+int RunningContext::ThreadSafeBlockingCall(
+    Napi::ObjectReference& jsObjectRef,
+    const std::string& jsFunctionName,
+    ArgumentsHandler argumentsHandler,
+    CompletionHandler completionHandler)
+{
+  std::promise<int> promise;
+  std::future<int> future = promise.get_future();
+
+  this->tsfn_.BlockingCall(&promise, [this, &jsObjectRef, jsFunctionName, argumentsHandler, completionHandler](Napi::Env env, Napi::Function jsCallback, std::promise<int>* promise) {
+    Napi::HandleScope scope(env);
+    auto deferred = Napi::Promise::Deferred::New(env);
+    try {
+      const std::vector<napi_value> arguments = argumentsHandler(env);
+      Napi::Function jsFunction = jsObjectRef.Value().Get(jsFunctionName).As<Napi::Function>();
+      Napi::Value result = jsFunction.Call(jsObjectRef.Value(), arguments);
+      deferred.Resolve(result);
+    } catch (const Napi::Error& e) {
+      deferred.Reject(e.Value());
+    } catch (const std::exception& e) {
+      deferred.Reject(Napi::Error::New(env, e.what()).Value());
+    }
+
+    auto thenCallback = Napi::Function::New(env, [this, promise, completionHandler](const Napi::CallbackInfo& info) {
+      Napi::Env env = info.Env();
+      Napi::HandleScope scope(env);
+      try {
+        int result = completionHandler(env, info[0].As<Napi::Value>());
+        promise->set_value(result);
+      } catch (const Napi::Error& e) {
+        this->Reject(info[0].As<Napi::Error>().Value());
+        promise->set_value(EDHOC_ERROR_GENERIC_ERROR);
+      } catch (const std::exception& e) {
+        this->Reject(Napi::Error::New(env, e.what()).Value());
+        promise->set_value(EDHOC_ERROR_GENERIC_ERROR);
+      }
+    });
+
+    auto catchCallback = Napi::Function::New(env, [this, promise](const Napi::CallbackInfo& info) {
+      Napi::Env env = info.Env();
+      Napi::HandleScope scope(env);
+      this->Reject(info[0].As<Napi::Error>().Value());
+      promise->set_value(EDHOC_ERROR_GENERIC_ERROR);
+    });
+
+    Napi::Promise promise_ = deferred.Promise();
+    promise_.Get("then").As<Napi::Function>().Call(promise_, { thenCallback, catchCallback });
+  });  
+
+  future.wait();
+  return future.get();
+}
+
+void RunningContext::Resolve(Napi::Value value) {
+    if (isResolved_) {
+        return;
+    }
+    deferred_.Resolve(value);
+    tsfn_.Release();
+    isResolved_ = true;
+}
+
+void RunningContext::Reject(Napi::Value value) {
+  if (isResolved_) {
+    return;
+  }
+  deferred_.Reject(value);
+  tsfn_.Release();
+  isResolved_ = true;
+}
+
+Napi::Promise RunningContext::GetPromise() const {
+    return deferred_.Promise();
+}