pj-nodegit 0.27.1 → 0.28.2

package/src/remote.cc

@@ -12,7 +12,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/remote.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/str_array_converter.h"
   #include "../include/remote_head.h"
@@ -37,61 +36,63 @@ using namespace node;
     // this will cause an error if you have a non-self-freeing object that also needs
     // to save values. Since the object that will eventually free the object has no
     // way of knowing to free these values.
-                                                                                                                                                                             }
+                                                                                                                                                                                 }
 
-  void GitRemote::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitRemote::InitializeComponent(v8::Local<v8::Object> target, nodegit::Context *nodegitContext) {
     Nan::HandleScope scope;
 
-    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
+    v8::Local<v8::External> nodegitExternal = Nan::New<v8::External>(nodegitContext);
+    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction, nodegitExternal);
 
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     tpl->SetClassName(Nan::New("Remote").ToLocalChecked());
 
-           Nan::SetMethod(tpl, "addFetch", AddFetch);
-             Nan::SetMethod(tpl, "addPush", AddPush);
-            Nan::SetPrototypeMethod(tpl, "autotag", Autotag);
-            Nan::SetPrototypeMethod(tpl, "connect", Connect);
-            Nan::SetPrototypeMethod(tpl, "connected", Connected);
-             Nan::SetMethod(tpl, "create", Create);
-             Nan::SetMethod(tpl, "createAnonymous", CreateAnonymous);
-             Nan::SetMethod(tpl, "createDetached", CreateDetached);
-             Nan::SetMethod(tpl, "createWithFetchspec", CreateWithFetchspec);
-             Nan::SetMethod(tpl, "createWithOpts", CreateWithOpts);
-            Nan::SetPrototypeMethod(tpl, "defaultBranch", DefaultBranch);
-             Nan::SetMethod(tpl, "delete", Delete);
-            Nan::SetPrototypeMethod(tpl, "disconnect", Disconnect);
-            Nan::SetPrototypeMethod(tpl, "download", Download);
-            Nan::SetPrototypeMethod(tpl, "dup", Dup);
-            Nan::SetPrototypeMethod(tpl, "fetch", Fetch);
-            Nan::SetPrototypeMethod(tpl, "getFetchRefspecs", GetFetchRefspecs);
-            Nan::SetPrototypeMethod(tpl, "getPushRefspecs", GetPushRefspecs);
-            Nan::SetPrototypeMethod(tpl, "getRefspec", GetRefspec);
-             Nan::SetMethod(tpl, "isValidName", IsValidName);
-             Nan::SetMethod(tpl, "list", List);
-             Nan::SetMethod(tpl, "lookup", Lookup);
-            Nan::SetPrototypeMethod(tpl, "name", Name);
-            Nan::SetPrototypeMethod(tpl, "owner", Owner);
-            Nan::SetPrototypeMethod(tpl, "prune", Prune);
-            Nan::SetPrototypeMethod(tpl, "pruneRefs", PruneRefs);
-            Nan::SetPrototypeMethod(tpl, "push", Push);
-            Nan::SetPrototypeMethod(tpl, "pushurl", Pushurl);
-            Nan::SetPrototypeMethod(tpl, "refspecCount", RefspecCount);
-             Nan::SetMethod(tpl, "rename", Rename);
-             Nan::SetMethod(tpl, "setAutotag", SetAutotag);
-             Nan::SetMethod(tpl, "setPushurl", SetPushurl);
-             Nan::SetMethod(tpl, "setUrl", SetUrl);
-            Nan::SetPrototypeMethod(tpl, "stats", Stats);
-            Nan::SetPrototypeMethod(tpl, "stop", Stop);
-            Nan::SetPrototypeMethod(tpl, "updateTips", UpdateTips);
-            Nan::SetPrototypeMethod(tpl, "upload", Upload);
-            Nan::SetPrototypeMethod(tpl, "url", Url);
-            Nan::SetPrototypeMethod(tpl, "referenceList", ReferenceList);
+           Nan::SetMethod(tpl, "addFetch", AddFetch, nodegitExternal);
+             Nan::SetMethod(tpl, "addPush", AddPush, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "autotag", Autotag, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "connect", Connect, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "connected", Connected, nodegitExternal);
+             Nan::SetMethod(tpl, "create", Create, nodegitExternal);
+             Nan::SetMethod(tpl, "createAnonymous", CreateAnonymous, nodegitExternal);
+             Nan::SetMethod(tpl, "createDetached", CreateDetached, nodegitExternal);
+             Nan::SetMethod(tpl, "createWithFetchspec", CreateWithFetchspec, nodegitExternal);
+             Nan::SetMethod(tpl, "createWithOpts", CreateWithOpts, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "defaultBranch", DefaultBranch, nodegitExternal);
+             Nan::SetMethod(tpl, "delete", Delete, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "disconnect", Disconnect, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "download", Download, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "dup", Dup, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "fetch", Fetch, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getFetchRefspecs", GetFetchRefspecs, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getPushRefspecs", GetPushRefspecs, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getRefspec", GetRefspec, nodegitExternal);
+             Nan::SetMethod(tpl, "isValidName", IsValidName, nodegitExternal);
+             Nan::SetMethod(tpl, "list", List, nodegitExternal);
+             Nan::SetMethod(tpl, "lookup", Lookup, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "name", Name, nodegitExternal);
+             Nan::SetMethod(tpl, "nameIsValid", NameIsValid, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "owner", Owner, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "prune", Prune, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "pruneRefs", PruneRefs, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "push", Push, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "pushurl", Pushurl, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "refspecCount", RefspecCount, nodegitExternal);
+             Nan::SetMethod(tpl, "rename", Rename, nodegitExternal);
+             Nan::SetMethod(tpl, "setAutotag", SetAutotag, nodegitExternal);
+             Nan::SetMethod(tpl, "setPushurl", SetPushurl, nodegitExternal);
+             Nan::SetMethod(tpl, "setUrl", SetUrl, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "stats", Stats, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "stop", Stop, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "updateTips", UpdateTips, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "upload", Upload, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "url", Url, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "referenceList", ReferenceList, nodegitExternal);
     
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("Remote").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitRemote::Template", constructor_template);
+    Nan::Set(target, Nan::New("Remote").ToLocalChecked(), constructor_template);
   }
 
   
@@ -149,7 +150,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_repo
@@ -166,11 +167,11 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -228,7 +229,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_repo
@@ -245,11 +246,11 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -262,7 +263,7 @@ NAN_METHOD(GitRemote::Autotag) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -273,11 +274,11 @@ NAN_METHOD(GitRemote::Autotag) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -293,78 +294,86 @@ NAN_METHOD(GitRemote::Connect) {
     return Nan::ThrowError("Number direction is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsObject()) {
-    return Nan::ThrowError("RemoteCallbacks callbacks is required.");
-  }
-
-  if (info.Length() == 2 || !info[2]->IsObject()) {
-    return Nan::ThrowError("ProxyOptions proxy_opts is required.");
-  }
-
-  if (info.Length() == 3 || !(Nan::To<bool>(info[3]).FromJust())) {
-    return Nan::ThrowError("Array, String Object, or string custom_headers is required.");
-  }
-  if (info.Length() == 4 || !info[4]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ConnectBaton* baton = new ConnectBaton;
+  ConnectBaton* baton = new ConnectBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 // start convert_from_v8 block
   git_direction from_direction;
       from_direction = (git_direction)  (int) info[0].As<v8::Number>()->Value();
 // end convert_from_v8 block
           baton->direction = from_direction;
-// start convert_from_v8 block
-  const git_remote_callbacks * from_callbacks = NULL;
-from_callbacks = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->callbacks = from_callbacks;
-// start convert_from_v8 block
-  const git_proxy_options * from_proxy_opts = NULL;
-from_proxy_opts = Nan::ObjectWrap::Unwrap<GitProxyOptions>(Nan::To<v8::Object>(info[2]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->proxy_opts = from_proxy_opts;
-// start convert_from_v8 block
+          if (info[1]->IsNull() || info[1]->IsUndefined()) {
+            baton->callbacks = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitRemoteCallbacks::fromJavascript(nodegitContext, info[1]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["callbacks"] = convertedObject;
+            baton->callbacks = convertedObject->GetValue();
+          }
+           if (info[2]->IsNull() || info[2]->IsUndefined()) {
+            baton->proxy_opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitProxyOptions::fromJavascript(nodegitContext, info[2]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["proxy_opts"] = convertedObject;
+            baton->proxy_opts = convertedObject->GetValue();
+          }
+ // start convert_from_v8 block
   const git_strarray * from_custom_headers = NULL;
 
   from_custom_headers = StrArrayConverter::Convert(info[3]);
 // end convert_from_v8 block
           baton->custom_headers = from_custom_headers;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  ConnectWorker *worker = new ConnectWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ConnectWorker *worker = new ConnectWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("remote", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("direction", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("callbacks", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("proxy_opts", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("custom_headers", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitRemote>("remote", info.This());
+           worker->Reference("direction", info[0]);
+            worker->Reference("callbacks", info[1]);
+            worker->Reference("proxy_opts", info[2]);
+            worker->Reference("custom_headers", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::ConnectWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->remote
+          ,baton->callbacks
+          ,baton->proxy_opts
+          ,baton->custom_headers
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::ConnectWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->remote
-            ,baton->callbacks
-            ,baton->proxy_opts
-            ,baton->custom_headers
-    );
-
     int result = git_remote_connect(
 baton->remote,baton->direction,baton->callbacks,baton->proxy_opts,baton->custom_headers  );
 
@@ -374,13 +383,42 @@ baton->remote,baton->direction,baton->callbacks,baton->proxy_opts,baton->custom_
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::ConnectWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.connect").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitRemote::ConnectWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+              {
+               auto objWrap = Nan::ObjectWrap::Unwrap<GitRemote>(GetFromPersistent("remote").As<v8::Object>());
+             objWrap->SaveCleanupHandle(cleanupHandles["callbacks"]);
+          }
+             {
+               auto objWrap = Nan::ObjectWrap::Unwrap<GitRemote>(GetFromPersistent("remote").As<v8::Object>());
+             objWrap->SaveCleanupHandle(cleanupHandles["proxy_opts"]);
+          }
+      
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -404,48 +442,15 @@ void GitRemote::ConnectWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("direction"));
-              workerArguments.push(GetFromPersistent("callbacks"));
-              workerArguments.push(GetFromPersistent("proxy_opts"));
-              workerArguments.push(GetFromPersistent("custom_headers"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -478,7 +483,7 @@ NAN_METHOD(GitRemote::Connected) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -489,11 +494,11 @@ NAN_METHOD(GitRemote::Connected) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -517,15 +522,19 @@ NAN_METHOD(GitRemote::Create) {
     return Nan::ThrowError("String url is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateBaton* baton = new CreateBaton;
+  CreateBaton* baton = new CreateBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -560,31 +569,31 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->url = from_url;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  CreateWorker *worker = new CreateWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("url", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateWorker *worker = new CreateWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+            worker->Reference("url", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::CreateWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->name
+          ,baton->url
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::CreateWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->name
-            ,baton->url
-    );
-
     int result = git_remote_create(
 &baton->out,baton->repo,baton->name,baton->url  );
 
@@ -594,12 +603,34 @@ void GitRemote::CreateWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::CreateWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.create").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      free(baton->out);
+
+  delete baton;
 }
 
 void GitRemote::CreateWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -611,18 +642,18 @@ void GitRemote::CreateWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitRemote::New(
+         v8ConversionSlot = GitRemote::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+         
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -646,47 +677,15 @@ void GitRemote::CreateWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("url"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -703,6 +702,7 @@ void GitRemote::CreateWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->out);
   }
 
 
@@ -725,15 +725,19 @@ NAN_METHOD(GitRemote::CreateAnonymous) {
     return Nan::ThrowError("String url is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateAnonymousBaton* baton = new CreateAnonymousBaton;
+  CreateAnonymousBaton* baton = new CreateAnonymousBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -754,28 +758,29 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->url = from_url;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  CreateAnonymousWorker *worker = new CreateAnonymousWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateAnonymousWorker *worker = new CreateAnonymousWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("url", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("url", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::CreateAnonymousWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->url
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::CreateAnonymousWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->url
-    );
-
     int result = git_remote_create_anonymous(
 &baton->out,baton->repo,baton->url  );
 
@@ -785,12 +790,34 @@ void GitRemote::CreateAnonymousWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::CreateAnonymousWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.createAnonymous").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      free(baton->out);
+
+  delete baton;
 }
 
 void GitRemote::CreateAnonymousWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -802,18 +829,18 @@ void GitRemote::CreateAnonymousWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitRemote::New(
+         v8ConversionSlot = GitRemote::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -837,46 +864,15 @@ void GitRemote::CreateAnonymousWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("url"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -893,6 +889,7 @@ void GitRemote::CreateAnonymousWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->out);
   }
 
 
@@ -910,15 +907,19 @@ NAN_METHOD(GitRemote::CreateDetached) {
     return Nan::ThrowError("String url is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateDetachedBaton* baton = new CreateDetachedBaton;
+  CreateDetachedBaton* baton = new CreateDetachedBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   const char * from_url = NULL;
 
@@ -934,25 +935,27 @@ NAN_METHOD(GitRemote::CreateDetached) {
 // end convert_from_v8 block
           baton->url = from_url;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  CreateDetachedWorker *worker = new CreateDetachedWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("url", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateDetachedWorker *worker = new CreateDetachedWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+           worker->Reference("url", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::CreateDetachedWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->url
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::CreateDetachedWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->url
-    );
-
     int result = git_remote_create_detached(
 &baton->out,baton->url  );
 
@@ -962,25 +965,47 @@ void GitRemote::CreateDetachedWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::CreateDetachedWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.createDetached").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      free(baton->out);
+
+  delete baton;
 }
 
 void GitRemote::CreateDetachedWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
-        to = GitRemote::New(
+        v8ConversionSlot = GitRemote::New(
         baton->out,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1004,45 +1029,15 @@ void GitRemote::CreateDetachedWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("url"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1059,6 +1054,7 @@ void GitRemote::CreateDetachedWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->out);
   }
 
 
@@ -1091,15 +1087,19 @@ NAN_METHOD(GitRemote::CreateWithFetchspec) {
     return Nan::ThrowError("String fetch is required.");
   }
 
-  if (info.Length() == 4 || !info[4]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateWithFetchspecBaton* baton = new CreateWithFetchspecBaton;
+  CreateWithFetchspecBaton* baton = new CreateWithFetchspecBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -1148,34 +1148,33 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->fetch = from_fetch;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  CreateWithFetchspecWorker *worker = new CreateWithFetchspecWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateWithFetchspecWorker *worker = new CreateWithFetchspecWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("url", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("fetch", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+            worker->Reference("url", info[2]);
+            worker->Reference("fetch", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::CreateWithFetchspecWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->name
+          ,baton->url
+          ,baton->fetch
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::CreateWithFetchspecWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->name
-            ,baton->url
-            ,baton->fetch
-    );
-
     int result = git_remote_create_with_fetchspec(
 &baton->out,baton->repo,baton->name,baton->url,baton->fetch  );
 
@@ -1185,12 +1184,34 @@ void GitRemote::CreateWithFetchspecWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::CreateWithFetchspecWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.createWithFetchspec").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      free(baton->out);
+
+  delete baton;
 }
 
 void GitRemote::CreateWithFetchspecWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -1202,18 +1223,18 @@ void GitRemote::CreateWithFetchspecWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitRemote::New(
+         v8ConversionSlot = GitRemote::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+           
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1237,48 +1258,15 @@ void GitRemote::CreateWithFetchspecWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("url"));
-              workerArguments.push(GetFromPersistent("fetch"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1295,6 +1283,7 @@ void GitRemote::CreateWithFetchspecWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->out);
   }
 
 
@@ -1313,15 +1302,19 @@ NAN_METHOD(GitRemote::CreateWithOpts) {
     return Nan::ThrowError("String url is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  CreateWithOptsBaton* baton = new CreateWithOptsBaton;
+  CreateWithOptsBaton* baton = new CreateWithOptsBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   const char * from_url = NULL;
 
@@ -1336,39 +1329,43 @@ NAN_METHOD(GitRemote::CreateWithOpts) {
   memset((void *)(((char *)from_url) + url.length()), 0, 1);
 // end convert_from_v8 block
           baton->url = from_url;
-// start convert_from_v8 block
-  const git_remote_create_options * from_opts = NULL;
-    if (info[1]->IsObject()) {
-from_opts = Nan::ObjectWrap::Unwrap<GitRemoteCreateOptions>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_opts = 0;
-  }
-// end convert_from_v8 block
-          baton->opts = from_opts;
+          if (info[1]->IsNull() || info[1]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitRemoteCreateOptions::fromJavascript(nodegitContext, info[1]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  CreateWithOptsWorker *worker = new CreateWithOptsWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  CreateWithOptsWorker *worker = new CreateWithOptsWorker(baton, callback);
+           worker->Reference("url", info[0]);
+            worker->Reference("opts", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("url", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+nodegit::LockMaster GitRemote::CreateWithOptsWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->url
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitRemote::CreateWithOptsWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->url
-            ,baton->opts
-    );
-
     int result = git_remote_create_with_opts(
 &baton->out,baton->url,baton->opts  );
 
@@ -1378,12 +1375,34 @@ void GitRemote::CreateWithOptsWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::CreateWithOptsWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.createWithOpts").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      free(baton->out);
+
+  delete baton;
 }
 
 void GitRemote::CreateWithOptsWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -1395,18 +1414,18 @@ void GitRemote::CreateWithOptsWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitRemote::New(
+         v8ConversionSlot = GitRemote::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+        
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1430,46 +1449,15 @@ void GitRemote::CreateWithOptsWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("url"));
-              workerArguments.push(GetFromPersistent("opts"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1486,6 +1474,7 @@ void GitRemote::CreateWithOptsWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->out);
   }
 
 
@@ -1498,39 +1487,46 @@ void GitRemote::CreateWithOptsWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitRemote::DefaultBranch) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  DefaultBranchBaton* baton = new DefaultBranchBaton;
+  DefaultBranchBaton* baton = new DefaultBranchBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  DefaultBranchWorker *worker = new DefaultBranchWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  DefaultBranchWorker *worker = new DefaultBranchWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("remote", info.This());
+        worker->Reference<GitRemote>("remote", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::DefaultBranchWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->remote
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::DefaultBranchWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->remote
-    );
-
     int result = git_remote_default_branch(
 baton->out,baton->remote  );
 
@@ -1540,22 +1536,45 @@ baton->out,baton->remote  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::DefaultBranchWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.defaultBranch").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitRemote::DefaultBranchWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1579,44 +1598,15 @@ void GitRemote::DefaultBranchWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1656,15 +1646,19 @@ NAN_METHOD(GitRemote::Delete) {
     return Nan::ThrowError("String name is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  DeleteBaton* baton = new DeleteBaton;
+  DeleteBaton* baton = new DeleteBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -1685,28 +1679,29 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  DeleteWorker *worker = new DeleteWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  DeleteWorker *worker = new DeleteWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::DeleteWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::DeleteWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->name
-    );
-
     int result = git_remote_delete(
 baton->repo,baton->name  );
 
@@ -1716,15 +1711,36 @@ baton->repo,baton->name  );
         baton->error = git_error_dup(git_error_last());
       }
 
-  }
 }
 
-void GitRemote::DeleteWorker::HandleOKCallback() {
-    if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> result = Nan::Undefined();
-
-    v8::Local<v8::Value> argv[2] = {
-      Nan::Null(),
+void GitRemote::DeleteWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.delete").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
+}
+
+void GitRemote::DeleteWorker::HandleOKCallback() {
+    if (baton->error_code == GIT_OK) {
+    v8::Local<v8::Value> result = Nan::Undefined();
+     
+    v8::Local<v8::Value> argv[2] = {
+      Nan::Null(),
       result
     };
     callback->Call(2, argv, async_resource);
@@ -1746,46 +1762,15 @@ void GitRemote::DeleteWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1813,35 +1798,42 @@ void GitRemote::DeleteWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitRemote::Disconnect) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  DisconnectBaton* baton = new DisconnectBaton;
+  DisconnectBaton* baton = new DisconnectBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  DisconnectWorker *worker = new DisconnectWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  DisconnectWorker *worker = new DisconnectWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("remote", info.This());
+        worker->Reference<GitRemote>("remote", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::DisconnectWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->remote
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::DisconnectWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->remote
-    );
-
     int result = git_remote_disconnect(
 baton->remote  );
 
@@ -1851,13 +1843,34 @@ baton->remote  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::DisconnectWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.disconnect").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitRemote::DisconnectWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1881,44 +1894,15 @@ void GitRemote::DisconnectWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1948,19 +1932,19 @@ void GitRemote::DisconnectWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitRemote::Download) {
 
-  if (info.Length() == 1 || !info[1]->IsObject()) {
-    return Nan::ThrowError("FetchOptions opts is required.");
-  }
-
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  DownloadBaton* baton = new DownloadBaton;
+  DownloadBaton* baton = new DownloadBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_strarray * from_refspecs = NULL;
@@ -1968,36 +1952,45 @@ NAN_METHOD(GitRemote::Download) {
   from_refspecs = StrArrayConverter::Convert(info[0]);
 // end convert_from_v8 block
           baton->refspecs = from_refspecs;
-// start convert_from_v8 block
-  const git_fetch_options * from_opts = NULL;
-from_opts = Nan::ObjectWrap::Unwrap<GitFetchOptions>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->opts = from_opts;
+          if (info[1]->IsNull() || info[1]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitFetchOptions::fromJavascript(nodegitContext, info[1]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  DownloadWorker *worker = new DownloadWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  DownloadWorker *worker = new DownloadWorker(baton, callback);
+        worker->Reference<GitRemote>("remote", info.This());
+           worker->Reference("refspecs", info[0]);
+            worker->Reference("opts", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        worker->SaveToPersistent("remote", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("refspecs", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+nodegit::LockMaster GitRemote::DownloadWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->remote
+          ,baton->refspecs
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitRemote::DownloadWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->remote
-            ,baton->refspecs
-            ,baton->opts
-    );
-
     int result = git_remote_download(
 baton->remote,baton->refspecs,baton->opts  );
 
@@ -2007,13 +2000,34 @@ baton->remote,baton->refspecs,baton->opts  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::DownloadWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.download").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitRemote::DownloadWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+        
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2037,46 +2051,15 @@ void GitRemote::DownloadWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("refspecs"));
-              workerArguments.push(GetFromPersistent("opts"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2105,35 +2088,42 @@ void GitRemote::DownloadWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitRemote::Dup) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  DupBaton* baton = new DupBaton;
+  DupBaton* baton = new DupBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->source = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  DupWorker *worker = new DupWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  DupWorker *worker = new DupWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("source", info.This());
+        worker->Reference<GitRemote>("source", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::DupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->source
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::DupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->source
-    );
-
     int result = git_remote_dup(
 &baton->dest,baton->source  );
 
@@ -2143,12 +2133,34 @@ void GitRemote::DupWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::DupWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.dup").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      free(baton->dest);
+
+  delete baton;
 }
 
 void GitRemote::DupWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->dest != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -2160,18 +2172,18 @@ void GitRemote::DupWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitRemote::New(
+         v8ConversionSlot = GitRemote::New(
         baton->dest,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2195,44 +2207,15 @@ void GitRemote::DupWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2249,6 +2232,7 @@ void GitRemote::DupWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        free(baton->dest);
   }
 
 
@@ -2263,19 +2247,19 @@ void GitRemote::DupWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitRemote::Fetch) {
 
-  if (info.Length() == 1 || !info[1]->IsObject()) {
-    return Nan::ThrowError("FetchOptions opts is required.");
-  }
-
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  FetchBaton* baton = new FetchBaton;
+  FetchBaton* baton = new FetchBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_strarray * from_refspecs = NULL;
@@ -2283,14 +2267,22 @@ NAN_METHOD(GitRemote::Fetch) {
   from_refspecs = StrArrayConverter::Convert(info[0]);
 // end convert_from_v8 block
           baton->refspecs = from_refspecs;
-// start convert_from_v8 block
-  const git_fetch_options * from_opts = NULL;
-from_opts = Nan::ObjectWrap::Unwrap<GitFetchOptions>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->opts = from_opts;
-// start convert_from_v8 block
+          if (info[1]->IsNull() || info[1]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitFetchOptions::fromJavascript(nodegitContext, info[1]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ // start convert_from_v8 block
   const char * from_reflog_message = NULL;
-    if (info[2]->IsString()) {
+    if ((info.Length() - 1) > 2 && info[2]->IsString()) {
 
   Nan::Utf8String reflog_message(Nan::To<v8::String>(info[2]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -2308,33 +2300,33 @@ from_opts = Nan::ObjectWrap::Unwrap<GitFetchOptions>(Nan::To<v8::Object>(info[1]
 // end convert_from_v8 block
           baton->reflog_message = from_reflog_message;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  FetchWorker *worker = new FetchWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FetchWorker *worker = new FetchWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("remote", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("refspecs", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("reflog_message", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitRemote>("remote", info.This());
+           worker->Reference("refspecs", info[0]);
+            worker->Reference("opts", info[1]);
+            worker->Reference("reflog_message", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::FetchWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->remote
+          ,baton->refspecs
+          ,baton->opts
+          ,baton->reflog_message
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::FetchWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->remote
-            ,baton->refspecs
-            ,baton->opts
-            ,baton->reflog_message
-    );
-
     int result = git_remote_fetch(
 baton->remote,baton->refspecs,baton->opts,baton->reflog_message  );
 
@@ -2344,13 +2336,34 @@ baton->remote,baton->refspecs,baton->opts,baton->reflog_message  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::FetchWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.fetch").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitRemote::FetchWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+          
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2374,47 +2387,15 @@ void GitRemote::FetchWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("refspecs"));
-              workerArguments.push(GetFromPersistent("opts"));
-              workerArguments.push(GetFromPersistent("reflog_message"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2443,37 +2424,44 @@ void GitRemote::FetchWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitRemote::GetFetchRefspecs) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetFetchRefspecsBaton* baton = new GetFetchRefspecsBaton;
+  GetFetchRefspecsBaton* baton = new GetFetchRefspecsBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->array = (git_strarray *)malloc(sizeof(git_strarray ));
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  GetFetchRefspecsWorker *worker = new GetFetchRefspecsWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetFetchRefspecsWorker *worker = new GetFetchRefspecsWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("remote", info.This());
+        worker->Reference<GitRemote>("remote", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::GetFetchRefspecsWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->array
+          ,baton->remote
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::GetFetchRefspecsWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->array
-            ,baton->remote
-    );
-
     int result = git_remote_get_fetch_refspecs(
 baton->array,baton->remote  );
 
@@ -2483,22 +2471,44 @@ baton->array,baton->remote  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::GetFetchRefspecsWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.getFetchRefspecs").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+        free((void*)baton->array);
+
+  delete baton;
 }
 
 void GitRemote::GetFetchRefspecsWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     v8::Local<Array> tmpArray = Nan::New<Array>(baton->array->count);
     for (unsigned int i = 0; i < baton->array->count; i++) {
       Nan::Set(tmpArray, Nan::New<Number>(i), Nan::New<v8::String>(baton->array->strings[i]).ToLocalChecked());
     }
  
-  to = tmpArray;
+  v8ConversionSlot = tmpArray;
  // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2522,44 +2532,15 @@ void GitRemote::GetFetchRefspecsWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2579,7 +2560,6 @@ void GitRemote::GetFetchRefspecsWorker::HandleOKCallback() {
           free((void*)baton->array);
   }
 
-        free((void *)baton->array);
 
   delete baton;
 }
@@ -2590,37 +2570,44 @@ void GitRemote::GetFetchRefspecsWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitRemote::GetPushRefspecs) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetPushRefspecsBaton* baton = new GetPushRefspecsBaton;
+  GetPushRefspecsBaton* baton = new GetPushRefspecsBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->array = (git_strarray *)malloc(sizeof(git_strarray ));
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  GetPushRefspecsWorker *worker = new GetPushRefspecsWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetPushRefspecsWorker *worker = new GetPushRefspecsWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("remote", info.This());
+        worker->Reference<GitRemote>("remote", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::GetPushRefspecsWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->array
+          ,baton->remote
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::GetPushRefspecsWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->array
-            ,baton->remote
-    );
-
     int result = git_remote_get_push_refspecs(
 baton->array,baton->remote  );
 
@@ -2630,22 +2617,44 @@ baton->array,baton->remote  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::GetPushRefspecsWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.getPushRefspecs").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+        free((void*)baton->array);
+
+  delete baton;
 }
 
 void GitRemote::GetPushRefspecsWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     v8::Local<Array> tmpArray = Nan::New<Array>(baton->array->count);
     for (unsigned int i = 0; i < baton->array->count; i++) {
       Nan::Set(tmpArray, Nan::New<Number>(i), Nan::New<v8::String>(baton->array->strings[i]).ToLocalChecked());
     }
  
-  to = tmpArray;
+  v8ConversionSlot = tmpArray;
  // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2669,44 +2678,15 @@ void GitRemote::GetPushRefspecsWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2726,7 +2706,6 @@ void GitRemote::GetPushRefspecsWorker::HandleOKCallback() {
           free((void*)baton->array);
   }
 
-        free((void *)baton->array);
 
   delete baton;
 }
@@ -2750,7 +2729,7 @@ NAN_METHOD(GitRemote::GetRefspec) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -2766,22 +2745,22 @@ NAN_METHOD(GitRemote::GetRefspec) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitRefspec::New(
+          v8ConversionSlot = GitRefspec::New(
         result,
         false
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -2812,7 +2791,7 @@ NAN_METHOD(GitRemote::IsValidName) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_remote_name
@@ -2823,11 +2802,11 @@ NAN_METHOD(GitRemote::IsValidName) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -2841,15 +2820,19 @@ NAN_METHOD(GitRemote::List) {
     return Nan::ThrowError("Repository repo is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ListBaton* baton = new ListBaton;
+  ListBaton* baton = new ListBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_strarray *)malloc(sizeof(git_strarray ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -2857,26 +2840,28 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->repo = from_repo;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  ListWorker *worker = new ListWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  ListWorker *worker = new ListWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+  
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::ListWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->repo
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::ListWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->repo
-    );
-
     int result = git_remote_list(
 baton->out,baton->repo  );
 
@@ -2886,22 +2871,44 @@ baton->out,baton->repo  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::ListWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.list").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+        free((void*)baton->out);
+
+  delete baton;
 }
 
 void GitRemote::ListWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     v8::Local<Array> tmpArray = Nan::New<Array>(baton->out->count);
     for (unsigned int i = 0; i < baton->out->count; i++) {
       Nan::Set(tmpArray, Nan::New<Number>(i), Nan::New<v8::String>(baton->out->strings[i]).ToLocalChecked());
     }
  
-  to = tmpArray;
+  v8ConversionSlot = tmpArray;
  // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2925,45 +2932,15 @@ void GitRemote::ListWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2983,7 +2960,6 @@ void GitRemote::ListWorker::HandleOKCallback() {
           free((void*)baton->out);
   }
 
-        free((void *)baton->out);
 
   delete baton;
 }
@@ -3004,15 +2980,19 @@ NAN_METHOD(GitRemote::Lookup) {
     return Nan::ThrowError("String name is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  LookupBaton* baton = new LookupBaton;
+  LookupBaton* baton = new LookupBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
 from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
@@ -3033,28 +3013,29 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  LookupWorker *worker = new LookupWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  LookupWorker *worker = new LookupWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::LookupWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->repo
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::LookupWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->repo
-            ,baton->name
-    );
-
     int result = git_remote_lookup(
 &baton->out,baton->repo,baton->name  );
 
@@ -3064,12 +3045,34 @@ void GitRemote::LookupWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::LookupWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.lookup").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+      git_remote_free(baton->out);
+
+  delete baton;
 }
 
 void GitRemote::LookupWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
@@ -3081,18 +3084,18 @@ void GitRemote::LookupWorker::HandleOKCallback() {
             true
           )).ToLocalChecked()
         );
-         to = GitRemote::New(
+         v8ConversionSlot = GitRemote::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3116,53 +3119,307 @@ void GitRemote::LookupWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
         }
+      }
+
+      if (!callbackFired) {
+        v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error("Method lookup has thrown an error.")).ToLocalChecked();
+        Nan::Set(err, Nan::New("errno").ToLocalChecked(), Nan::New(baton->error_code));
+        Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.lookup").ToLocalChecked());
+        v8::Local<v8::Value> argv[1] = {
+          err
+        };
+        callback->Call(1, argv, async_resource);
+      }
+    } else {
+      callback->Call(0, NULL, async_resource);
+    }
+
+        git_remote_free(baton->out);
+  }
+
+
+  delete baton;
+}
+
+   
+/*
+     * @return String  result    */
+NAN_METHOD(GitRemote::Name) {
+  Nan::EscapableHandleScope scope;
+
+
+  git_error_clear();
 
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
+  { // lock master scope start
+    nodegit::LockMaster lockMaster(
+      /*asyncAction: */false
+            ,
+              Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
+    );
+
+ const char * result =     git_remote_name(
+          Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
+    );
+
+        // null checks on pointers
+        if (!result) {
+          return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
+        }
+
+      v8::Local<v8::Value> v8ConversionSlot;
+// start convert_to_v8 block
+  if (result){
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
+   }
+  else {
+    v8ConversionSlot = Nan::Null();
+  }
+
+  // end convert_to_v8 block
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
+  }
+}
+   
+/*
+ * @param Number valid
+   * @param String remote_name
+     * @return Number  result    */
+NAN_METHOD(GitRemote::NameIsValid) {
+  Nan::EscapableHandleScope scope;
+
+  if (info.Length() == 0 || !info[0]->IsNumber()) {
+    return Nan::ThrowError("Number valid is required.");
+  }
+
+  if (info.Length() == 1 || !info[1]->IsString()) {
+    return Nan::ThrowError("String remote_name is required.");
+  }
+
+// start convert_from_v8 block
+  int * from_valid = NULL;
+      *from_valid = (int)   info[0].As<v8::Number>()->Value();
+// end convert_from_v8 block
+// start convert_from_v8 block
+  const char * from_remote_name = NULL;
+
+  Nan::Utf8String remote_name(Nan::To<v8::String>(info[1]).ToLocalChecked());
+  // malloc with one extra byte so we can add the terminating null character C-strings expect:
+  from_remote_name = (const char *) malloc(remote_name.length() + 1);
+  // copy the characters from the nodejs string into our C-string (used instead of strdup or strcpy because nulls in
+  // the middle of strings are valid coming from nodejs):
+  memcpy((void *)from_remote_name, *remote_name, remote_name.length());
+  // ensure the final byte of our new string is null, extra casts added to ensure compatibility with various C types
+  // used in the nodejs binding generation:
+  memset((void *)(((char *)from_remote_name) + remote_name.length()), 0, 1);
+// end convert_from_v8 block
+
+  git_error_clear();
+
+  { // lock master scope start
+    nodegit::LockMaster lockMaster(
+      /*asyncAction: */false
+            ,
+              from_valid
+            ,
+              from_remote_name
+    );
+
+ int result =     git_remote_name_is_valid(
+          from_valid
+,          from_remote_name
+    );
+
+
+      v8::Local<v8::Value> v8ConversionSlot;
+// start convert_to_v8 block
+     v8ConversionSlot = Nan::New<Number>( result);
+  // end convert_to_v8 block
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
+  }
+}
+   
+/*
+     * @return Repository  result    */
+NAN_METHOD(GitRemote::Owner) {
+  Nan::EscapableHandleScope scope;
+
+
+  git_error_clear();
+
+  { // lock master scope start
+    nodegit::LockMaster lockMaster(
+      /*asyncAction: */false
+            ,
+              Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
+    );
+
+ git_repository * result =     git_remote_owner(
+          Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
+    );
+
+        // null checks on pointers
+        if (!result) {
+          return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
+        }
+
+      v8::Local<v8::Value> v8ConversionSlot;
+// start convert_to_v8 block
+    if (result != NULL) {
+        v8ConversionSlot = GitRepository::New(
+        result,
+        true
+       );
+   }
+  else {
+    v8ConversionSlot = Nan::Null();
+  }
+  // end convert_to_v8 block
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
+  }
+}
+  
+/*
+   * @param RemoteCallbacks callbacks
+     */
+NAN_METHOD(GitRemote::Prune) {
+
+  if (!info[info.Length() - 1]->IsFunction()) {
+    return Nan::ThrowError("Callback is required and must be a Function.");
+  }
+
+  PruneBaton* baton = new PruneBaton();
+
+  baton->error_code = GIT_OK;
+  baton->error = NULL;
+
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
+        baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
+          if (info[0]->IsNull() || info[0]->IsUndefined()) {
+            baton->callbacks = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitRemoteCallbacks::fromJavascript(nodegitContext, info[0]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["callbacks"] = convertedObject;
+            baton->callbacks = convertedObject->GetValue();
           }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  PruneWorker *worker = new PruneWorker(baton, callback, cleanupHandles);
+
+        worker->Reference<GitRemote>("remote", info.This());
+           worker->Reference("callbacks", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
+
+nodegit::LockMaster GitRemote::PruneWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->remote
+          ,baton->callbacks
+  );
+
+  return lockMaster;
+}
+
+void GitRemote::PruneWorker::Execute() {
+  git_error_clear();
+
+    int result = git_remote_prune(
+baton->remote,baton->callbacks  );
+
+      baton->error_code = result;
+
+      if (result != GIT_OK && git_error_last() != NULL) {
+        baton->error = git_error_dup(git_error_last());
+      }
+
+}
+
+void GitRemote::PruneWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.prune").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
+}
+
+void GitRemote::PruneWorker::HandleOKCallback() {
+    if (baton->error_code == GIT_OK) {
+    v8::Local<v8::Value> result = Nan::Undefined();
+      
+    v8::Local<v8::Value> argv[2] = {
+      Nan::Null(),
+      result
+    };
+    callback->Call(2, argv, async_resource);
+  } else {
+    if (baton->error) {
+      v8::Local<v8::Object> err;
+      if (baton->error->message) {
+        err = Nan::To<v8::Object>(Nan::Error(baton->error->message)).ToLocalChecked();
+      } else {
+        err = Nan::To<v8::Object>(Nan::Error("Method prune has thrown an error.")).ToLocalChecked();
+      }
+      Nan::Set(err, Nan::New("errno").ToLocalChecked(), Nan::New(baton->error_code));
+      Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.prune").ToLocalChecked());
+      v8::Local<v8::Value> argv[1] = {
+        err
+      };
+      callback->Call(1, argv, async_resource);
+      if (baton->error->message)
+        free((void *)baton->error->message);
+      free((void *)baton->error);
+    } else if (baton->error_code < 0) {
+      bool callbackFired = false;
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
+          v8::Local<v8::Value> argv[1] = {
+            maybeError
+          };
+          callback->Call(1, argv, async_resource);
+          callbackFired = true;
         }
       }
 
       if (!callbackFired) {
-        v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error("Method lookup has thrown an error.")).ToLocalChecked();
+        v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error("Method prune has thrown an error.")).ToLocalChecked();
         Nan::Set(err, Nan::New("errno").ToLocalChecked(), Nan::New(baton->error_code));
-        Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.lookup").ToLocalChecked());
+        Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.prune").ToLocalChecked());
         v8::Local<v8::Value> argv[1] = {
           err
         };
@@ -3179,124 +3436,6 @@ void GitRemote::LookupWorker::HandleOKCallback() {
 }
 
    
-/*
-     * @return String  result    */
-NAN_METHOD(GitRemote::Name) {
-  Nan::EscapableHandleScope scope;
-
-
-  git_error_clear();
-
-  { // lock master scope start
-    LockMaster lockMaster(
-      /*asyncAction: */false
-            ,
-              Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
-    );
-
- const char * result =     git_remote_name(
-          Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
-    );
-
-        // null checks on pointers
-        if (!result) {
-          return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
-        }
-
-      v8::Local<v8::Value> to;
-// start convert_to_v8 block
-  if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
-   }
-  else {
-    to = Nan::Null();
-  }
-
-  // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
-  }
-}
-   
-/*
-     * @return Repository  result    */
-NAN_METHOD(GitRemote::Owner) {
-  Nan::EscapableHandleScope scope;
-
-
-  git_error_clear();
-
-  { // lock master scope start
-    LockMaster lockMaster(
-      /*asyncAction: */false
-            ,
-              Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
-    );
-
- git_repository * result =     git_remote_owner(
-          Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
-    );
-
-        // null checks on pointers
-        if (!result) {
-          return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
-        }
-
-      v8::Local<v8::Value> to;
-// start convert_to_v8 block
-    if (result != NULL) {
-        to = GitRepository::New(
-        result,
-        true
-       );
-   }
-  else {
-    to = Nan::Null();
-  }
-  // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
-  }
-}
-   
-/*
-   * @param RemoteCallbacks callbacks
-     * @return Number  result    */
-NAN_METHOD(GitRemote::Prune) {
-  Nan::EscapableHandleScope scope;
-
-  if (info.Length() == 0 || !info[0]->IsObject()) {
-    return Nan::ThrowError("RemoteCallbacks callbacks is required.");
-  }
-
-// start convert_from_v8 block
-  const git_remote_callbacks * from_callbacks = NULL;
-from_callbacks = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-
-  git_error_clear();
-
-  { // lock master scope start
-    LockMaster lockMaster(
-      /*asyncAction: */false
-            ,
-              Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
-            ,
-              from_callbacks
-    );
-
- int result =     git_remote_prune(
-          Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
-,          from_callbacks
-    );
-
-
-      v8::Local<v8::Value> to;
-// start convert_to_v8 block
-     to = Nan::New<Number>( result);
-  // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
-  }
-}
-   
 /*
      * @return Number  result    */
 NAN_METHOD(GitRemote::PruneRefs) {
@@ -3306,7 +3445,7 @@ NAN_METHOD(GitRemote::PruneRefs) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -3317,11 +3456,11 @@ NAN_METHOD(GitRemote::PruneRefs) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -3331,18 +3470,19 @@ NAN_METHOD(GitRemote::PruneRefs) {
      */
 NAN_METHOD(GitRemote::Push) {
 
-  if (info.Length() == 0 || !(Nan::To<bool>(info[0]).FromJust())) {
-    return Nan::ThrowError("Array, String Object, or string refspecs is required.");
-  }
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  PushBaton* baton = new PushBaton;
+  PushBaton* baton = new PushBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_strarray * from_refspecs = NULL;
@@ -3350,41 +3490,45 @@ NAN_METHOD(GitRemote::Push) {
   from_refspecs = StrArrayConverter::Convert(info[0]);
 // end convert_from_v8 block
           baton->refspecs = from_refspecs;
-// start convert_from_v8 block
-  const git_push_options * from_opts = NULL;
-    if (info[1]->IsObject()) {
-from_opts = Nan::ObjectWrap::Unwrap<GitPushOptions>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
-  }
-  else {
-    from_opts = 0;
-  }
-// end convert_from_v8 block
-          baton->opts = from_opts;
+          if (info[1]->IsNull() || info[1]->IsUndefined()) {
+            baton->opts = nullptr;
+          } else
+            {
+            auto conversionResult = ConfigurableGitPushOptions::fromJavascript(nodegitContext, info[1]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  PushWorker *worker = new PushWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  PushWorker *worker = new PushWorker(baton, callback);
+        worker->Reference<GitRemote>("remote", info.This());
+           worker->Reference("refspecs", info[0]);
+            worker->Reference("opts", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        worker->SaveToPersistent("remote", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("refspecs", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+nodegit::LockMaster GitRemote::PushWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->remote
+          ,baton->refspecs
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitRemote::PushWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->remote
-            ,baton->refspecs
-            ,baton->opts
-    );
-
     int result = git_remote_push(
 baton->remote,baton->refspecs,baton->opts  );
 
@@ -3394,13 +3538,34 @@ baton->remote,baton->refspecs,baton->opts  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::PushWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.push").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitRemote::PushWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+        
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3424,46 +3589,15 @@ void GitRemote::PushWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("refspecs"));
-              workerArguments.push(GetFromPersistent("opts"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3496,7 +3630,7 @@ NAN_METHOD(GitRemote::Pushurl) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -3511,17 +3645,17 @@ NAN_METHOD(GitRemote::Pushurl) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3534,7 +3668,7 @@ NAN_METHOD(GitRemote::RefspecCount) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -3545,11 +3679,11 @@ NAN_METHOD(GitRemote::RefspecCount) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -3573,15 +3707,19 @@ NAN_METHOD(GitRemote::Rename) {
     return Nan::ThrowError("String new_name is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  RenameBaton* baton = new RenameBaton;
+  RenameBaton* baton = new RenameBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->problems = (git_strarray *)malloc(sizeof(git_strarray ));
 // start convert_from_v8 block
   git_repository * from_repo = NULL;
@@ -3617,32 +3755,32 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
 // end convert_from_v8 block
           baton->new_name = from_new_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  RenameWorker *worker = new RenameWorker(baton, callback);
-
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("repo", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("new_name", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  RenameWorker *worker = new RenameWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+             worker->Reference<GitRepository>("repo", info[0]);
+             worker->Reference("name", info[1]);
+            worker->Reference("new_name", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::RenameWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->problems
+          ,baton->repo
+          ,baton->name
+          ,baton->new_name
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::RenameWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->problems
-            ,baton->repo
-            ,baton->name
-            ,baton->new_name
-    );
-
     int result = git_remote_rename(
 baton->problems,baton->repo,baton->name,baton->new_name  );
 
@@ -3652,22 +3790,44 @@ baton->problems,baton->repo,baton->name,baton->new_name  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::RenameWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.rename").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+        free((void*)baton->problems);
+
+  delete baton;
 }
 
 void GitRemote::RenameWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     v8::Local<Array> tmpArray = Nan::New<Array>(baton->problems->count);
     for (unsigned int i = 0; i < baton->problems->count; i++) {
       Nan::Set(tmpArray, Nan::New<Number>(i), Nan::New<v8::String>(baton->problems->strings[i]).ToLocalChecked());
     }
  
-  to = tmpArray;
+  v8ConversionSlot = tmpArray;
  // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+         
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3691,47 +3851,15 @@ void GitRemote::RenameWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("repo"));
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("new_name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3751,7 +3879,6 @@ void GitRemote::RenameWorker::HandleOKCallback() {
           free((void*)baton->problems);
   }
 
-        free((void *)baton->problems);
 
   delete baton;
 }
@@ -3802,7 +3929,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_repo
@@ -3817,11 +3944,11 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3879,7 +4006,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_repo
@@ -3896,11 +4023,11 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3958,7 +4085,7 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               from_repo
@@ -3975,11 +4102,11 @@ from_repo = Nan::ObjectWrap::Unwrap<GitRepository>(Nan::To<v8::Object>(info[0]).
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -3992,7 +4119,7 @@ NAN_METHOD(GitRemote::Stats) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -4007,22 +4134,22 @@ NAN_METHOD(GitRemote::Stats) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (result != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, owners->Length(), info.This());
-          to = GitIndexerProgress::New(
+          v8ConversionSlot = GitIndexerProgress::New(
         result,
         false
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
    
@@ -4035,7 +4162,7 @@ NAN_METHOD(GitRemote::Stop) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -4046,11 +4173,11 @@ NAN_METHOD(GitRemote::Stop) {
     );
 
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>( result);
+     v8ConversionSlot = Nan::New<Number>( result);
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
   
@@ -4074,22 +4201,31 @@ NAN_METHOD(GitRemote::UpdateTips) {
     return Nan::ThrowError("Number download_tags is required.");
   }
 
-  if (info.Length() == 4 || !info[4]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  UpdateTipsBaton* baton = new UpdateTipsBaton;
+  UpdateTipsBaton* baton = new UpdateTipsBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
-// start convert_from_v8 block
-  const git_remote_callbacks * from_callbacks = NULL;
-from_callbacks = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->callbacks = from_callbacks;
-// start convert_from_v8 block
+            {
+            auto conversionResult = ConfigurableGitRemoteCallbacks::fromJavascript(nodegitContext, info[0]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["callbacks"] = convertedObject;
+            baton->callbacks = convertedObject->GetValue();
+          }
+ // start convert_from_v8 block
   int from_update_fetchhead;
       from_update_fetchhead = (int)   info[1].As<v8::Number>()->Value();
 // end convert_from_v8 block
@@ -4101,7 +4237,7 @@ from_callbacks = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(Nan::To<v8::Object>
           baton->download_tags = from_download_tags;
 // start convert_from_v8 block
   const char * from_reflog_message = NULL;
-    if (info[3]->IsString()) {
+    if ((info.Length() - 1) > 3 && info[3]->IsString()) {
 
   Nan::Utf8String reflog_message(Nan::To<v8::String>(info[3]).ToLocalChecked());
   // malloc with one extra byte so we can add the terminating null character C-strings expect:
@@ -4119,34 +4255,33 @@ from_callbacks = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(Nan::To<v8::Object>
 // end convert_from_v8 block
           baton->reflog_message = from_reflog_message;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[4]));
-  UpdateTipsWorker *worker = new UpdateTipsWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  UpdateTipsWorker *worker = new UpdateTipsWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("remote", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("callbacks", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("update_fetchhead", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("download_tags", Nan::To<v8::Object>(info[2]).ToLocalChecked());
-        if (!info[3]->IsUndefined() && !info[3]->IsNull())
-          worker->SaveToPersistent("reflog_message", Nan::To<v8::Object>(info[3]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitRemote>("remote", info.This());
+           worker->Reference("callbacks", info[0]);
+            worker->Reference("update_fetchhead", info[1]);
+            worker->Reference("download_tags", info[2]);
+            worker->Reference("reflog_message", info[3]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::UpdateTipsWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->remote
+          ,baton->callbacks
+          ,baton->reflog_message
+  );
+
+  return lockMaster;
+}
+
 void GitRemote::UpdateTipsWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->remote
-            ,baton->callbacks
-            ,baton->reflog_message
-    );
-
     int result = git_remote_update_tips(
 baton->remote,baton->callbacks,baton->update_fetchhead,baton->download_tags,baton->reflog_message  );
 
@@ -4156,13 +4291,34 @@ baton->remote,baton->callbacks,baton->update_fetchhead,baton->download_tags,bato
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::UpdateTipsWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.updateTips").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitRemote::UpdateTipsWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+            
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -4186,48 +4342,15 @@ void GitRemote::UpdateTipsWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("callbacks"));
-              workerArguments.push(GetFromPersistent("update_fetchhead"));
-              workerArguments.push(GetFromPersistent("download_tags"));
-              workerArguments.push(GetFromPersistent("reflog_message"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -4257,22 +4380,23 @@ void GitRemote::UpdateTipsWorker::HandleOKCallback() {
      */
 NAN_METHOD(GitRemote::Upload) {
 
-  if (info.Length() == 0 || !(Nan::To<bool>(info[0]).FromJust())) {
-    return Nan::ThrowError("Array, String Object, or string refspecs is required.");
-  }
   if (info.Length() == 1 || !info[1]->IsObject()) {
     return Nan::ThrowError("PushOptions opts is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  UploadBaton* baton = new UploadBaton;
+  UploadBaton* baton = new UploadBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 // start convert_from_v8 block
   const git_strarray * from_refspecs = NULL;
@@ -4280,36 +4404,42 @@ NAN_METHOD(GitRemote::Upload) {
   from_refspecs = StrArrayConverter::Convert(info[0]);
 // end convert_from_v8 block
           baton->refspecs = from_refspecs;
-// start convert_from_v8 block
-  const git_push_options * from_opts = NULL;
-from_opts = Nan::ObjectWrap::Unwrap<GitPushOptions>(Nan::To<v8::Object>(info[1]).ToLocalChecked())->GetValue();
-// end convert_from_v8 block
-          baton->opts = from_opts;
+            {
+            auto conversionResult = ConfigurableGitPushOptions::fromJavascript(nodegitContext, info[1]);
+            if (!conversionResult.result) {
+              return Nan::ThrowError(Nan::New(conversionResult.error).ToLocalChecked());
+            }
+
+            auto convertedObject = conversionResult.result;
+            cleanupHandles["opts"] = convertedObject;
+            baton->opts = convertedObject->GetValue();
+          }
+ 
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  UploadWorker *worker = new UploadWorker(baton, callback, cleanupHandles);
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  UploadWorker *worker = new UploadWorker(baton, callback);
+        worker->Reference<GitRemote>("remote", info.This());
+           worker->Reference("refspecs", info[0]);
+            worker->Reference("opts", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
+  return;
+}
 
-        worker->SaveToPersistent("remote", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("refspecs", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("opts", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+nodegit::LockMaster GitRemote::UploadWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->remote
+          ,baton->refspecs
+          ,baton->opts
+  );
 
-  AsyncLibgit2QueueWorker(worker);
-  return;
+  return lockMaster;
 }
 
 void GitRemote::UploadWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->remote
-            ,baton->refspecs
-            ,baton->opts
-    );
-
     int result = git_remote_upload(
 baton->remote,baton->refspecs,baton->opts  );
 
@@ -4319,13 +4449,34 @@ baton->remote,baton->refspecs,baton->opts  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitRemote::UploadWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Remote.upload").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitRemote::UploadWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+        
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -4349,46 +4500,15 @@ void GitRemote::UploadWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("refspecs"));
-              workerArguments.push(GetFromPersistent("opts"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -4421,7 +4541,7 @@ NAN_METHOD(GitRemote::Url) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue()
@@ -4436,71 +4556,85 @@ NAN_METHOD(GitRemote::Url) {
           return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
         }
 
-      v8::Local<v8::Value> to;
+      v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
   if (result){
-       to = Nan::New<v8::String>(result).ToLocalChecked();
+       v8ConversionSlot = Nan::New<v8::String>(result).ToLocalChecked();
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
 
   // end convert_to_v8 block
-        return info.GetReturnValue().Set(scope.Escape(to));
+        return info.GetReturnValue().Set(scope.Escape(v8ConversionSlot));
   }
 }
         NAN_METHOD(GitRemote::ReferenceList)
 {
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  ReferenceListBaton* baton = new ReferenceListBaton;
+  ReferenceListBaton* baton = new ReferenceListBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
   baton->out = new std::vector<git_remote_head*>;
   baton->remote = Nan::ObjectWrap::Unwrap<GitRemote>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[0]));
-  ReferenceListWorker *worker = new ReferenceListWorker(baton, callback);
-  worker->SaveToPersistent("remote", info.This());
-  Nan::AsyncQueueWorker(worker);
+  Nan::Callback *callback = new Nan::Callback(Local<Function>::Cast(info[info.Length() - 1]));
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+  ReferenceListWorker *worker = new ReferenceListWorker(baton, callback, cleanupHandles);
+  worker->Reference<GitRemote>("remote", info.This());
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitRemote::ReferenceListWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(true, baton->remote);
+  return lockMaster;
+}
+
 void GitRemote::ReferenceListWorker::Execute()
 {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true,
-      baton->remote
-    );
+  const git_remote_head **remote_heads;
+  size_t num_remote_heads;
+  baton->error_code = git_remote_ls(
+    &remote_heads,
+    &num_remote_heads,
+    baton->remote
+  );
 
-    const git_remote_head **remote_heads;
-    size_t num_remote_heads;
-    baton->error_code = git_remote_ls(
-      &remote_heads,
-      &num_remote_heads,
-      baton->remote
-    );
+  if (baton->error_code != GIT_OK) {
+    baton->error = git_error_dup(git_error_last());
+    delete baton->out;
+    baton->out = NULL;
+    return;
+  }
 
-    if (baton->error_code != GIT_OK) {
-      baton->error = git_error_dup(git_error_last());
-      delete baton->out;
-      baton->out = NULL;
-      return;
-    }
+  baton->out->reserve(num_remote_heads);
 
-    baton->out->reserve(num_remote_heads);
+  for (size_t head_index = 0; head_index < num_remote_heads; ++head_index) {
+    git_remote_head *remote_head = git_remote_head_dup(remote_heads[head_index]);
+    baton->out->push_back(remote_head);
+  }
+}
 
-    for (size_t head_index = 0; head_index < num_remote_heads; ++head_index) {
-      git_remote_head *remote_head = git_remote_head_dup(remote_heads[head_index]);
-      baton->out->push_back(remote_head);
+void GitRemote::ReferenceListWorker::HandleErrorCallback() {
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
     }
+
+    free((void *)baton->error);
   }
+
+  delete baton->out;
+
+  delete baton;
 }
 
 void GitRemote::ReferenceListWorker::HandleOKCallback()
@@ -4548,6 +4682,8 @@ void GitRemote::ReferenceListWorker::HandleOKCallback()
   {
     callback->Call(0, NULL, async_resource);
   }
+
+  delete baton;
 }
 
     // force base class template instantiation, to make sure we get all the