edhoc 1.2.3 → 1.3.0

package/include/EdhocCryptoManager.h

@@ -7,6 +7,8 @@ extern "C" {
 #include "edhoc.h"
 }
 
+class RunningContext;
+
 /**
  * @class EdhocCryptoManager
  * @brief Manages cryptographic operations for EDHOC protocol.
@@ -22,20 +24,20 @@ class EdhocCryptoManager {
 
   /**
    * @struct edhoc_crypto
-   * @brief Libedhoc's bind structure for cryptographics operations.
+   * @brief Edhoc's bind structure for cryptographics operations.
    */
   struct edhoc_crypto crypto;
 
   /**
    * @struct edhoc_keys
-   * @brief Libedhoc's bind structure for cryptographic key identifiers.
+   * @brief Edhoc's bind structure for cryptographic key identifiers.
    */
   struct edhoc_keys keys;
 
   /**
    * @brief Constructs an EdhocCryptoManager object.
    */
-  EdhocCryptoManager(Napi::Object& jsCryptoManager);
+  EdhocCryptoManager(Napi::Object& jsCryptoManager, Napi::Object& jsEdhoc);
 
   /**
    * @brief Destroys the EdhocCryptoManager object.
@@ -265,14 +267,14 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the ImportKey function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_type The type of the key to import.
    * @param raw_key The raw key data.
    * @param raw_key_length The length of the raw key data.
    * @param key_id The imported key ID.
    * @return int The result code.
    */
-  int callImportKey(const void* user_context,
+  int callImportKey(RunningContext* runningContext,
                     enum edhoc_key_type key_type,
                     const uint8_t* raw_key,
                     size_t raw_key_length,
@@ -285,12 +287,12 @@ class EdhocCryptoManager {
    * @param key_id The key ID to destroy.
    * @return int The result code.
    */
-  int callDestroyKey(const void* user_context, void* key_id);
+  int callDestroyKey(RunningContext* runningContext, void* key_id);
 
   /**
    * @brief Calls the MakeKeyPair function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_id The key ID.
    * @param private_key The buffer to store the private key.
    * @param private_key_size The size of the private key buffer.
@@ -300,7 +302,7 @@ class EdhocCryptoManager {
    * @param public_key_length The length of the generated public key.
    * @return int The result code.
    */
-  int callMakeKeyPair(const void* user_context,
+  int callMakeKeyPair(RunningContext* runningContext,
                       const void* key_id,
                       uint8_t* private_key,
                       size_t private_key_size,
@@ -312,7 +314,7 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the KeyAgreement function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_id The key ID.
    * @param peer_public_key The peer's public key.
    * @param peer_public_key_length The length of the peer's public key.
@@ -321,7 +323,7 @@ class EdhocCryptoManager {
    * @param shared_secret_length The length of the generated shared secret.
    * @return int The result code.
    */
-  int callKeyAgreement(const void* user_context,
+  int callKeyAgreement(RunningContext* runningContext,
                        const void* key_id,
                        const uint8_t* peer_public_key,
                        size_t peer_public_key_length,
@@ -332,7 +334,7 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the Sign function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_id The key ID.
    * @param input The input data to sign.
    * @param input_length The length of the input data.
@@ -341,7 +343,7 @@ class EdhocCryptoManager {
    * @param signature_length The length of the generated signature.
    * @return int The result code.
    */
-  int callSign(const void* user_context,
+  int callSign(RunningContext* runningContext,
                const void* key_id,
                const uint8_t* input,
                size_t input_length,
@@ -352,7 +354,7 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the Verify function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_id The key ID.
    * @param input The input data.
    * @param input_length The length of the input data.
@@ -360,7 +362,7 @@ class EdhocCryptoManager {
    * @param signature_length The length of the signature.
    * @return int The result code.
    */
-  int callVerify(const void* user_context,
+  int callVerify(RunningContext* runningContext,
                  const void* key_id,
                  const uint8_t* input,
                  size_t input_length,
@@ -370,7 +372,7 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the Extract function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_id The key ID.
    * @param salt The salt data.
    * @param salt_len The length of the salt data.
@@ -380,7 +382,7 @@ class EdhocCryptoManager {
    * key.
    * @return int The result code.
    */
-  int callExtract(const void* user_context,
+  int callExtract(RunningContext* runningContext,
                   const void* key_id,
                   const uint8_t* salt,
                   size_t salt_len,
@@ -391,7 +393,7 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the Expand function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_id The key ID.
    * @param info The info data.
    * @param info_length The length of the info data.
@@ -401,7 +403,7 @@ class EdhocCryptoManager {
    * keying material.
    * @return int The result code.
    */
-  int callExpand(const void* user_context,
+  int callExpand(RunningContext* runningContext,
                  const void* key_id,
                  const uint8_t* info,
                  size_t info_length,
@@ -411,7 +413,7 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the Encrypt function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_id The key ID.
    * @param nonce The nonce data.
    * @param nonce_length The length of the nonce data.
@@ -424,7 +426,7 @@ class EdhocCryptoManager {
    * @param ciphertext_length The length of the generated ciphertext.
    * @return int The result code.
    */
-  int callEncrypt(const void* user_context,
+  int callEncrypt(RunningContext* runningContext,
                   const void* key_id,
                   const uint8_t* nonce,
                   size_t nonce_length,
@@ -439,7 +441,7 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the Decrypt function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param key_id The key ID.
    * @param nonce The nonce data.
    * @param nonce_length The length of the nonce data.
@@ -452,7 +454,7 @@ class EdhocCryptoManager {
    * @param plaintext_length The length of the generated plaintext.
    * @return int The result code.
    */
-  int callDecrypt(const void* user_context,
+  int callDecrypt(RunningContext* runningContext,
                   const void* key_id,
                   const uint8_t* nonce,
                   size_t nonce_length,
@@ -467,7 +469,7 @@ class EdhocCryptoManager {
   /**
    * @brief Calls the Hash function.
    *
-   * @param user_context The user context.
+   * @param runningContext The running context.
    * @param input The input data to hash.
    * @param input_length The length of the input data.
    * @param hash The buffer to store the hash.
@@ -475,37 +477,19 @@ class EdhocCryptoManager {
    * @param hash_length The length of the generated hash.
    * @return int The result code.
    */
-  int callHash(const void* user_context,
+  int callHash(RunningContext* runningContext,
                const uint8_t* input,
                size_t input_length,
                uint8_t* hash,
                size_t hash_size,
                size_t* hash_length);
-  /**
-   * @brief Sets up the async functions.
-   */
-  void SetupAsyncFunctions();
-
-  /**
-   * @brief Releases the async functions.
-   */
-  void CleanupAsyncFunctions();
 
  private:
   Napi::ObjectReference cryptoManagerRef;  ///< Reference to the JS object
+  Napi::ObjectReference edhocRef;
 
   std::vector<Napi::Reference<Napi::Buffer<uint8_t>>> bufferReferences;  ///< References to the JS buffers
 
-  /* Thread-safe functions */
-  Napi::ThreadSafeFunction importTsfn, destroyTsfn, makeKeyPairTsfn, keyAgreementTsfn, signTsfn, verifyTsfn,
-      extractTsfn, expandTsfn, encryptTsfn, decryptTsfn, hashTsfn;
-
-  /**
-   * @brief Assosciates the thread-safe function with the JS object function.
-   * @param name The name of the function in the JS credential manager object.
-   * @param tsfn The thread-safe function.
-   */
-  void SetFunction(const char* name, Napi::ThreadSafeFunction& tsfn);
 };
 
 #endif  // EDHOC_CRYPTO_MANAGER_H

package/include/EdhocEadManager.h

@@ -2,7 +2,6 @@
 #define EDHOC_EAD_MANAGER_H
 
 #include <napi.h>
-
 #include <map>
 #include <vector>
 
@@ -30,7 +29,7 @@ class EdhocEadManager {
  public:
   /**
    * @struct edhoc_ead
-   * @brief Libedhoc's bind structure for EAD operations.
+   * @brief Edhoc's bind structure for EAD operations.
    */
   struct edhoc_ead ead;
 
@@ -87,8 +86,8 @@ class EdhocEadManager {
   void ClearEadByMessage(enum edhoc_message message);
 
  private:
-  EadBufferMap eadBuffers;  ///< Map to store the EAD buffers for different
-                            ///< EDHOC messages.
+  EadBufferMap eadBuffers_;  ///< Map to store the EAD buffers for different
+                             ///< EDHOC messages.
 
   /**
    * @brief Static callback function for composing an EAD token.

package/include/EdhocExportOscoreAsyncWorker.h

@@ -2,36 +2,27 @@
 #define EDHOC_EXPORT_OSCORE_ASYNC_WORKER_H
 
 #include <napi.h>
-
 #include <functional>
 #include <vector>
 
+#include "RunningContext.h"
+
 extern "C" {
 #include "edhoc.h"
 }
 
 /**
  * @class EdhocExportOscoreAsyncWorker
- * @brief A class that represents an asynchronous worker for exporting Edhoc
- * context.
- *
- * This class inherits from Napi::AsyncWorker and provides methods for executing
- * the export operation asynchronously and handling the result or error.
+ * @brief A class that represents an asynchronous worker for exporting OSCORE context.
  */
 class EdhocExportOscoreAsyncWorker : public Napi::AsyncWorker {
  public:
-  /**
-   * @brief The type definition for the callback function.
-   */
-  using CallbackType = std::function<void(Napi::Env&)>;
-
   /**
    * @brief Constructs a new EdhocExportOscoreAsyncWorker object.
    *
-   * @param env The Napi::Env object representing the current environment.
-   * @param context The reference to the edhoc_context structure.
+   * @param runningContext The pointer to the running context.
    */
-  EdhocExportOscoreAsyncWorker(Napi::Env& env, struct edhoc_context& context, CallbackType callback);
+  EdhocExportOscoreAsyncWorker(RunningContext* runningContext);
 
   /**
    * @brief Destroys the EdhocExportOscoreAsyncWorker object.
@@ -55,20 +46,12 @@ class EdhocExportOscoreAsyncWorker : public Napi::AsyncWorker {
    */
   void OnError(const Napi::Error& error) override;
 
-  /**
-   * @brief Returns the promise object.
-   * @return The promise object.
-   */
-  Napi::Promise GetPromise();
-
  private:
-  Napi::Promise::Deferred deferred;   ///< The deferred promise object.
-  struct edhoc_context& context;      ///< The reference to the edhoc_context structure.
-  std::vector<uint8_t> masterSecret;  ///< The master secret.
-  std::vector<uint8_t> masterSalt;    ///< The master salt.
-  std::vector<uint8_t> senderId;      ///< The sender ID.
-  std::vector<uint8_t> recipientId;   ///< The recipient ID.
-  CallbackType callback;              ///< The callback function to be executed.
+  RunningContext* runningContext_;     ///< The pointer to the running context.
+  std::vector<uint8_t> masterSecret_;  ///< The master secret.
+  std::vector<uint8_t> masterSalt_;    ///< The master salt.
+  std::vector<uint8_t> senderId_;      ///< The sender ID.
+  std::vector<uint8_t> recipientId_;   ///< The recipient ID.
 };
 
 #endif  // EDHOC_EXPORT_OSCORE_ASYNC_WORKER_H

package/include/EdhocKeyExporterAsyncWorker.h

@@ -2,9 +2,10 @@
 #define EDHOC_KEY_EXPORTER_ASYNC_WORKER_H
 
 #include <napi.h>
-
 #include <vector>
 
+#include "RunningContext.h"
+
 extern "C" {
 #include "edhoc.h"
 }
@@ -12,19 +13,9 @@ extern "C" {
 /**
  * @class EdhocKeyExporterAsyncWorker
  * @brief A class that represents an asynchronous worker for exporting PRKs.
- *
- * This class inherits from the Napi::AsyncWorker class and is used to perform
- * PRK export in a separate thread. It takes an Edhoc context, a label, a
- * desired length, and a callback function as input parameters. The export is
- * performed in the Execute() method, and the result is returned through the
- * OnOK() method or an error is handled through the OnError() method.
  */
 class EdhocKeyExporterAsyncWorker : public Napi::AsyncWorker {
  public:
-  /**
-   * @brief The type definition for the callback function.
-   */
-  using CallbackType = std::function<void(Napi::Env&)>;
 
   /**
    * @brief Constructs a new EdhocKeyExporterAsyncWorker object.
@@ -33,13 +24,10 @@ class EdhocKeyExporterAsyncWorker : public Napi::AsyncWorker {
    * @param context The reference to the edhoc_context structure.
    * @param label The label of the key to export.
    * @param desiredLength The desired length of the key to export.
-   * @param callback The callback function to be called after the export.
    */
-  EdhocKeyExporterAsyncWorker(Napi::Env& env,
-                              struct edhoc_context& context,
+  EdhocKeyExporterAsyncWorker(RunningContext* runningContext,
                               uint16_t label,
-                              uint8_t desiredLength,
-                              CallbackType callback);
+                              uint8_t desiredLength);
 
   /**
    * @brief Executes the asynchronous worker task.
@@ -58,19 +46,11 @@ class EdhocKeyExporterAsyncWorker : public Napi::AsyncWorker {
    */
   void OnError(const Napi::Error& error) override;
 
-  /**
-   * @brief Returns the promise object.
-   * @return The promise object.
-   */
-  Napi::Promise GetPromise();
-
  private:
-  Napi::Promise::Deferred deferred;
-  struct edhoc_context& context;
-  uint16_t label;
-  uint8_t desiredLength;
-  std::vector<uint8_t> output;
-  CallbackType callback;
+  RunningContext* runningContext_; ///< Pointer to the running context.
+  uint16_t label_;                 ///< The label of the key to export.
+  uint8_t desiredLength_;          ///< The desired length of the key to export.
+  std::vector<uint8_t> output_;    ///< The output vector.
 };
 
 #endif  // EDHOC_KEY_EXPORTER_ASYNC_WORKER_H

package/include/EdhocKeyUpdateAsyncWorker.h

@@ -2,9 +2,10 @@
 #define EDHOC_KEY_UPDATE_ASYNC_WORKER_H
 
 #include <napi.h>
-
 #include <vector>
 
+#include "RunningContext.h"
+
 extern "C" {
 #include "edhoc.h"
 }
@@ -12,12 +13,6 @@ extern "C" {
 /**
  * @class EdhocKeyUpdateAsyncWorker
  * @brief A class that represents an asynchronous worker for key update.
- *
- * This class inherits from the Napi::AsyncWorker class and is used to perform
- * key update in a separate thread. It takes an Edhoc context, a context buffer,
- * and a callback function as input parameters. The key update is performed
- * in the Execute() method, and the result is returned through the OnOK() method
- * or an error is handled through the OnError() method.
  */
 class EdhocKeyUpdateAsyncWorker : public Napi::AsyncWorker {
  public:
@@ -29,15 +24,11 @@ class EdhocKeyUpdateAsyncWorker : public Napi::AsyncWorker {
   /**
    * @brief Constructs a new EdhocKeyUpdateAsyncWorker object.
    *
-   * @param env The Napi::Env object representing the current environment.
-   * @param context The reference to the edhoc_context structure.
+   * @param runningContext The running context.
    * @param contextBuffer The context buffer.
-   * @param callback The callback function to be called after the key update.
    */
-  EdhocKeyUpdateAsyncWorker(Napi::Env& env,
-                            struct edhoc_context& context,
-                            std::vector<uint8_t> contextBuffer,
-                            CallbackType callback);
+  EdhocKeyUpdateAsyncWorker(RunningContext *runningContext,
+                            std::vector<uint8_t> contextBuffer);
 
   /**
    * @brief Executes the asynchronous worker task.
@@ -56,17 +47,9 @@ class EdhocKeyUpdateAsyncWorker : public Napi::AsyncWorker {
    */
   void OnError(const Napi::Error& error) override;
 
-  /**
-   * @brief Returns the promise object.
-   * @return The promise object.
-   */
-  Napi::Promise GetPromise();
-
  private:
-  Napi::Promise::Deferred deferred;
-  struct edhoc_context& context;
-  std::vector<uint8_t> contextBuffer;
-  CallbackType callback;
+  RunningContext* runningContext_;     ///< Pointer to the running context.
+  std::vector<uint8_t> contextBuffer_; ///< The context buffer.
 };
 
 #endif  // EDHOC_KEY_UPDATE_ASYNC_WORKER_H

package/include/EdhocProcessAsyncWorker.h

@@ -2,47 +2,31 @@
 #define EDHOC_PROCESS_ASYNC_WORKER_H
 
 #include <napi.h>
-
 #include <vector>
 
+#include "RunningContext.h"
+
 extern "C" {
 #include "edhoc.h"
 }
 
 /**
  * @class EdhocProcessAsyncWorker
- * @brief A class that represents an asynchronous worker for processing Edhoc
- * messages.
- *
- * This class inherits from the Napi::AsyncWorker class and is used to perform
- * Edhoc message processing in a separate thread. It takes an Edhoc context,
- * message number, message buffer, and a callback function as input parameters.
- * The processing is performed in the Execute() method, and the result is
- * returned through the OnOK() method or an error is handled through the
- * OnError() method.
+ * @brief A class that represents an asynchronous worker for processing Edhoc messages.
  */
 class EdhocProcessAsyncWorker : public Napi::AsyncWorker {
  public:
-  /**
-   * @brief The type definition for the callback function.
-   */
-  using CallbackType = std::function<Napi::Array(Napi::Env&)>;
 
   /**
    * @brief Constructs a new instance of the EdhocProcessAsyncWorker class.
    *
-   * @param env The Napi::Env object.
-   * @param context The reference to the edhoc_context structure.
+   * @param runningContext The running context.
    * @param messageNumber The message number.
-   * @param buffer The Napi::Buffer<uint8_t> object containing the message
-   * buffer.
-   * @param callback The callback function to be called after processing.
+   * @param buffer The Napi::Buffer<uint8_t> object containing the message buffer.
    */
-  EdhocProcessAsyncWorker(Napi::Env& env,
-                          struct edhoc_context& context,
+  EdhocProcessAsyncWorker(RunningContext* runningContext,
                           int messageNumber,
-                          Napi::Buffer<uint8_t> buffer,
-                          CallbackType callback);
+                          Napi::Buffer<uint8_t> buffer);
 
   /**
    * @brief Executes the asynchronous worker task.
@@ -61,20 +45,11 @@ class EdhocProcessAsyncWorker : public Napi::AsyncWorker {
    */
   void OnError(const Napi::Error& error) override;
 
-  /**
-   * @brief Returns the promise object.
-   * @return The promise object.
-   */
-  Napi::Promise GetPromise();
-
  private:
-  Napi::Promise::Deferred deferred;       ///< The Napi::Promise::Deferred object for
-                                          ///< resolving or rejecting the promise.
-  struct edhoc_context& context;          ///< The reference to the edhoc_context structure.
-  int messageNumber;                      ///< The message number.
-  std::vector<uint8_t> messageBuffer;     ///< The message buffer.
-  CallbackType callback;                  ///< The callback function to be called after processing.
-  std::vector<uint8_t> peerCipherSuites;  ///< The peer cipher suites.
+  RunningContext* runningContext_;         ///< The pointer to the running context.
+  int messageNumber_;                      ///< The message number.
+  std::vector<uint8_t> messageBuffer_;     ///< The message buffer.
+  std::vector<uint8_t> peerCipherSuites_;  ///< The peer cipher suites.
 };
 
 #endif  // EDHOC_PROCESS_ASYNC_WORKER_H

package/include/RunningContext.h

@@ -0,0 +1,102 @@
+#ifndef RUNNING_CONTEXT_H
+#define RUNNING_CONTEXT_H
+
+#include <napi.h>
+#include <future>
+
+#include "EdhocCredentialManager.h"
+#include "EdhocCryptoManager.h"
+#include "EdhocEadManager.h"
+
+extern "C" {
+#include "edhoc.h"
+}
+
+/**
+ * @brief RunningContext is a class that manages the running context of the Edhoc library.
+ * It is used to handle the asynchronous calls to the Edhoc library.
+ */
+class RunningContext {
+ public:
+  /**
+   * @brief ArgumentsHandler is a function that takes an Napi::Env and returns a vector of Napi::Value.
+   */
+  using ArgumentsHandler = std::function<std::vector<napi_value>(Napi::Env)>;
+  /**
+   * @brief CompletionHandler is a function that takes an Napi::Env and a Napi::Value and returns an int.
+   */
+  using CompletionHandler = std::function<int(Napi::Env, Napi::Value)>;
+  
+  /**
+   * @brief Constructs a new RunningContext object.
+   * @param env The Napi::Env object.
+   * @param edhoc_context The pointer to the edhoc_context object.
+   * @param cryptoManager The pointer to the cryptoManager object.
+   * @param eadManager The pointer to the eadManager object.
+   * @param credentialManager The pointer to the credentialManager object.
+   */
+  RunningContext(Napi::Env env, 
+                 struct edhoc_context* edhoc_context,
+                 EdhocCryptoManager* cryptoManager,
+                 EdhocEadManager* eadManager,
+                 EdhocCredentialManager* credentialManager,
+                 const Napi::Function& logger);
+      
+  /**
+   * @brief Get the Napi::Env object.
+   * @return The Napi::Env object.
+   */
+  Napi::Env GetEnv() const { return deferred_.Env(); }
+
+  /**
+   * @brief ThreadSafeBlockingCall is a function that takes an Napi::ObjectReference, a std::string, an ArgumentsHandler, and a CompletionHandler and returns an int.
+   * @param jsObjectRef The Napi::ObjectReference object.
+   * @param jsFunctionName The name of the function to call.
+   * @param argumentsHandler The ArgumentsHandler object.
+   * @param completionHandler The CompletionHandler object.
+   * @return The int.
+   */
+  int ThreadSafeBlockingCall(Napi::ObjectReference& jsObjectRef,
+                             const std::string& jsFunctionName,
+                             ArgumentsHandler argumentsHandler,
+                             CompletionHandler completionHandler);
+
+  /**
+   * @brief Resolve is a function that takes an Napi::Value and resolves the promise.
+   * @param value The Napi::Value object.
+   */
+  void Resolve(Napi::Value value);
+
+  /**
+   * @brief Reject is a function that takes an Napi::Value and rejects the promise.
+   * @param value The Napi::Value object.
+   */
+  void Reject(Napi::Value value);
+
+  /**
+   * @brief GetPromise is a function that returns the promise.
+   * @return The Napi::Promise object.
+   */
+  Napi::Promise GetPromise() const;
+
+  // Raw pointer getters
+  Napi::ThreadSafeFunction GetTsfn() const { return tsfn_; }
+  EdhocCryptoManager* GetCryptoManager() const { return cryptoManager_; }
+  EdhocEadManager* GetEadManager() const { return eadManager_; }
+  EdhocCredentialManager* GetCredentialManager() const { return credentialManager_; }
+  struct edhoc_context* GetEdhocContext() const { return edhoc_context_; }
+  Napi::FunctionReference& GetLoggerRef() { return loggerRef_; }
+  
+ private:
+  struct edhoc_context* edhoc_context_;       ///< Pointer to the edhoc_context object.
+  EdhocCryptoManager* cryptoManager_;         ///< Pointer to the cryptoManager object.
+  EdhocEadManager* eadManager_;               ///< Pointer to the eadManager object.
+  EdhocCredentialManager* credentialManager_; ///< Pointer to the credentialManager object.
+  Napi::ThreadSafeFunction tsfn_;             ///< ThreadSafeFunction object.
+  Napi::Promise::Deferred deferred_;          ///< Deferred object.
+  Napi::FunctionReference loggerRef_;           ///< Reference to the logger function.
+  bool isResolved_;                           ///< Boolean to check if the promise is resolved.
+  
+};
+
+#endif  // RUNNING_CONTEXT_H