edhoc 1.2.2 → 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));
@@ -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,17 +10,13 @@ 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() {}
 
@@ -28,17 +24,17 @@ void EdhocExportOscoreAsyncWorker::Execute() {
   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);
+      senderId_.resize(sender_id_length);
+      recipientId_.resize(recipient_id_length);
     }
 
   } catch (const std::exception& e) {
@@ -50,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);
@@ -61,17 +57,11 @@ void EdhocExportOscoreAsyncWorker::OnOK() {
   resultObj.Set(kPropSenderId, senderIdBuffer);
   resultObj.Set(kPropRecipientId, recipientIdBuffer);
 
-  deferred.Resolve(resultObj);
-  callback(env);
+  runningContext_->Resolve(resultObj);
 }
 
 void EdhocExportOscoreAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Reject(error.Value());
-  callback(env);
-}
-
-Napi::Promise EdhocExportOscoreAsyncWorker::GetPromise() {
-  return deferred.Promise();
+  runningContext_->Reject(error.Value());
 }

package/src/EdhocKeyExporterAsyncWorker.cpp

@@ -3,22 +3,18 @@
 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() {
   try {
-    int ret = edhoc_export_prk_exporter(&context, label, output.data(), desiredLength);
+    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);
@@ -32,18 +28,12 @@ void EdhocKeyExporterAsyncWorker::Execute() {
 void EdhocKeyExporterAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  auto outputBuffer = Napi::Buffer<uint8_t>::Copy(env, output.data(), output.size());
-  deferred.Resolve(outputBuffer);
-  callback(env);
+  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);
-  deferred.Reject(error.Value());
-  callback(env);
-}
-
-Napi::Promise EdhocKeyExporterAsyncWorker::GetPromise() {
-  return deferred.Promise();
+  runningContext_->Reject(error.Value());
 }

package/src/EdhocKeyUpdateAsyncWorker.cpp

@@ -1,18 +1,14 @@
 #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() {
   try {
-    int ret = edhoc_export_key_update(&context, contextBuffer.data(), contextBuffer.size());
+    int ret = edhoc_export_key_update(runningContext_->GetEdhocContext(), contextBuffer_.data(), contextBuffer_.size());
 
     if (ret != EDHOC_SUCCESS) {
       SetError("Failed to update key.");
@@ -25,17 +21,11 @@ void EdhocKeyUpdateAsyncWorker::Execute() {
 void EdhocKeyUpdateAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Resolve(env.Undefined());
-  callback(env);
+  runningContext_->Resolve(env.Undefined());
 }
 
 void EdhocKeyUpdateAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Reject(error.Value());
-  callback(env);
-}
-
-Napi::Promise EdhocKeyUpdateAsyncWorker::GetPromise() {
-  return deferred.Promise();
+  runningContext_->Reject(error.Value());
 }

package/src/EdhocProcessAsyncWorker.cpp

@@ -6,37 +6,33 @@ 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() {
   try {
-    uint8_t* message = messageBuffer.data();
-    size_t message_length = messageBuffer.size();
+    uint8_t* message = messageBuffer_.data();
+    size_t message_length = messageBuffer_.size();
 
     int ret = EDHOC_ERROR_GENERIC_ERROR;
-    switch (messageNumber) {
+    switch (messageNumber_) {
       case EDHOC_MSG_1:
-        ret = edhoc_message_1_process(&context, message, message_length);
+        ret = edhoc_message_1_process(runningContext_->GetEdhocContext(), message, message_length);
         break;
       case EDHOC_MSG_2:
-        ret = edhoc_message_2_process(&context, message, message_length);
+        ret = edhoc_message_2_process(runningContext_->GetEdhocContext(), message, message_length);
         break;
       case EDHOC_MSG_3:
-        ret = edhoc_message_3_process(&context, message, message_length);
+        ret = edhoc_message_3_process(runningContext_->GetEdhocContext(), message, message_length);
         break;
       case EDHOC_MSG_4:
-        ret = edhoc_message_4_process(&context, message, message_length);
+        ret = edhoc_message_4_process(runningContext_->GetEdhocContext(), message, message_length);
         break;
       default:
         SetError(kErrorInvalidMessageNumber);
@@ -45,7 +41,7 @@ void EdhocProcessAsyncWorker::Execute() {
 
     if (ret != EDHOC_SUCCESS) {
       enum edhoc_error_code error_code = EDHOC_ERROR_CODE_SUCCESS;
-      ret = edhoc_error_get_code(&context, &error_code);
+      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;
@@ -53,7 +49,7 @@ void EdhocProcessAsyncWorker::Execute() {
           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,
+          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 = "[";
@@ -74,7 +70,7 @@ void EdhocProcessAsyncWorker::Execute() {
             }
             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(),
@@ -89,7 +85,7 @@ void EdhocProcessAsyncWorker::Execute() {
       }
 
       char errorMessage[kErrorBufferSize];
-      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber + 1, error_code);
+      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber_ + 1, error_code);
       SetError(errorMessage);
     }
 
@@ -101,27 +97,24 @@ void EdhocProcessAsyncWorker::Execute() {
 void EdhocProcessAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  Napi::Array result = callback(env);
-  deferred.Resolve(result);
-  callback(env);
+  
+  Napi::Array EADs = runningContext_->GetEadManager()->GetEadByMessage(env, static_cast<enum edhoc_message>(messageNumber_));
+  runningContext_->GetEadManager()->ClearEadByMessage(static_cast<enum edhoc_message>(messageNumber_));
+
+  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);
   }
 
-  deferred.Reject(error.Value());
-  callback(env);
-}
-
-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();
+} 

package/src/Utils.cpp

@@ -4,47 +4,10 @@
 #include <cstring>
 #include <mutex>
 #include <thread>
+#include <iostream>
 
-static constexpr const char* kStringThen = "then";
-static constexpr const char* kStringCatch = "catch";
 static constexpr const char* kErrorInputValueMustBeANumberOrABuffer = "Input value must be a number or a buffer";
 
-void Utils::InvokeJSFunctionWithPromiseHandling(Napi::Env env,
-                                                Napi::Object jsObject,
-                                                Napi::Function jsCallback,
-                                                const std::vector<napi_value>& args,
-                                                SuccessHandler successLambda,
-                                                ErrorHandler errorLambda) {
-  auto deferred = Napi::Promise::Deferred::New(env);
-
-  try {
-    Napi::Value result = jsCallback.Call(jsObject, args);
-    deferred.Resolve(result);
-  } catch (const Napi::Error& e) {
-    deferred.Reject(e.Value());
-  }
-
-  auto thenCallback = Napi::Function::New(env, [successLambda, errorLambda](const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    try {
-      successLambda(env, info[0].As<Napi::Value>());
-    } catch (const std::exception& e) {
-      errorLambda(env, Napi::Error::New(env, e.what()));
-    }
-  });
-
-  auto catchCallback = Napi::Function::New(env, [errorLambda](const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    errorLambda(env, info[0].As<Napi::Error>());
-  });
-
-  Napi::Promise promise = deferred.Promise();
-  promise.Get(kStringCatch).As<Napi::Function>().Call(promise, {catchCallback});
-  promise.Get(kStringThen).As<Napi::Function>().Call(promise, {thenCallback});
-}
-
 void Utils::EncodeInt64ToBuffer(int64_t value, uint8_t* buffer, size_t* length) {
   size_t idx = 0;
   if (value == 0) {

package/test/basic.test.ts

@@ -1,15 +1,40 @@
-import { EDHOC, X509CertificateCredentialManager, DefaultEdhocCryptoManager, EdhocMethod, EdhocSuite } from '../dist/index'
+import { randomBytes } from 'crypto';
+import { EDHOC, X509CertificateCredentialManager, DefaultEdhocCryptoManager, EdhocMethod, EdhocSuite, EdhocKeyType } from '../dist/index'
 
 describe('EDHOC Handshake', () => {
     // Test setup variables
     const trustedCA = Buffer.from('308201323081DAA003020102021478408C6EC18A1D452DAE70C726CB0192A6116DBB300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333635335A170D3235313031393138333635335A301A3118301606035504030C0F5468697320697320434120526F6F743059301306072A8648CE3D020106082A8648CE3D03010703420004B9348A8A267EF52CFDC30109A29008A2D99F6B8F78BA9EAF5D51578C06134E78CB90A073EDC2488A14174B4E2997C840C5DE7F8E35EB54A0DB6977E894D1B2CB300A06082A8648CE3D040302034700304402203B92BFEC770B0FA4E17F8F02A13CD945D914ED8123AC85C37C8C7BAA2BE3E0F102202CB2DC2EC295B5F4B7BB631ED751179C145D6B6E081559AEA38CE215369E9C31', 'hex');
     let initiator: EDHOC;
     let responder: EDHOC;
+    
+    let staticDhKeyInitiator: Buffer;
+    let staticDhKeyResponder: Buffer;
+    
+    let initiatorCredentialManager: X509CertificateCredentialManager;
+    let responderCredentialManager: X509CertificateCredentialManager;
+
+    class StaticCryptoManager extends DefaultEdhocCryptoManager {
+
+        async importKey(edhoc: EDHOC, keyType: EdhocKeyType, key: Buffer) {
+            if (keyType === EdhocKeyType.MakeKeyPair && key && edhoc.connectionID === 10) {
+                key = staticDhKeyInitiator
+            }
+            if (keyType === EdhocKeyType.MakeKeyPair && key && edhoc.connectionID === 20) {
+                key = staticDhKeyResponder
+            }
+            return super.importKey(edhoc, keyType, key);
+        }
+    }
+
+    beforeAll(() => {
+        staticDhKeyInitiator = randomBytes(32);
+        staticDhKeyResponder = randomBytes(32);
+    })
 
     beforeEach(() => {
         // Initialize credentials and crypto managers for both parties
         const initiatorKeyID = Buffer.from('00000001', 'hex');
-        const initiatorCredentialManager = new X509CertificateCredentialManager(
+        initiatorCredentialManager = new X509CertificateCredentialManager(
             [Buffer.from('3082012E3081D4A003020102021453423D5145C767CDC29895C3DB590192A611EA50300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333732345A170D3235313031393138333732345A30143112301006035504030C09696E69746961746F723059301306072A8648CE3D020106082A8648CE3D03010703420004EB0EF585F3992A1653CF310BF0F0F8035267CDAB6989C8B02E7228FBD759EF6B56263259AADF087F9849E7B7651F74C3B4F144CCCF86BB6FE2FF0EF3AA5FB5DC300A06082A8648CE3D0403020349003046022100D8C3AA7C98A730B3D4862EDAB4C1474FCD9A17A9CA3FB078914A10978FE95CC40221009F5877DD4E2C635A04ED1F6F1854C87B58521BDDFF533B1076F53D456739764C', 'hex')],
             initiatorKeyID
         );
@@ -19,7 +44,7 @@ describe('EDHOC Handshake', () => {
         initiatorCryptoManager.addKey(initiatorKeyID, Buffer.from('DC1FBB05B6B08360CE5B9EEA08EBFBFC6766A21340641863D4C8A3F68F096337', 'hex'));
 
         const responderKeyID = Buffer.from('00000002', 'hex');
-        const responderCredentialManager = new X509CertificateCredentialManager(
+        responderCredentialManager = new X509CertificateCredentialManager(
             [Buffer.from('3082012E3081D4A00302010202146648869E2608FC2E16D945C10E1F0192A6125CC0300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333735345A170D3235313031393138333735345A30143112301006035504030C09726573706F6E6465723059301306072A8648CE3D020106082A8648CE3D03010703420004161F76A7A106C9B79B7F651156B5B095E63A6101A39020F4E86DDACE61FB395E8AEF6CD9C444EE9A43DBD62DAD44FF50FE4146247D3AFD28F60DBC01FBFC573C300A06082A8648CE3D0403020349003046022100E8AD0926518CDB61E84D171700C7158FD0E72D03A117D40133ECD10F8B9F42CE022100E7E69B4C79100B3F0792F010AE11EE5DD2859C29EFC4DBCEFD41FA5CD4D3C3C9', 'hex')],
             responderKeyID
         );
@@ -61,4 +86,33 @@ describe('EDHOC Handshake', () => {
         const responderKey = await responder.exportKey(40001, 32);
         expect(initiatorKey).toEqual(responderKey);
     });
+
+    test('should fail to generate message 1 twice', async () => {
+        await initiator.composeMessage1();
+        await expect(initiator.composeMessage1()).rejects.toThrow();
+    });
+
+    describe('should NOT fail to generate message 1 twice', () => {
+
+        it('messages should be different', async () => {
+            const message_a = await responder.composeMessage1();
+            await responder.reset();
+            const message_b = await responder.composeMessage1();
+            expect(message_a).not.toEqual(message_b);
+        });
+
+        it('messages should be the same', async () => {
+            const initiatorCryptoManager = new StaticCryptoManager();
+            const responderCryptoManager = new StaticCryptoManager();
+            
+            initiator = new EDHOC(10, [EdhocMethod.Method1], [EdhocSuite.Suite2], initiatorCredentialManager, initiatorCryptoManager);
+            responder = new EDHOC(20, [EdhocMethod.Method2, EdhocMethod.Method0, EdhocMethod.Method1], [EdhocSuite.Suite2], responderCredentialManager, responderCryptoManager);
+
+            const message_a = await responder.composeMessage1();
+            await responder.reset();
+            const message_b = await responder.composeMessage1();
+
+            expect(message_a).toEqual(message_b);
+        });
+    });
 });