From 196f2030b8eb8c1494786036e6cfb8eab12a30d7 Mon Sep 17 00:00:00 2001 From: clintar Date: Fri, 10 Apr 2015 14:17:52 -0600 Subject: [PATCH 1/4] Initial commit of changes to get this to build using nan. Not sure what I'm doing, though. Not tested --- .gitignore | 1 + binding.gyp | 1 + multihashing.cc | 344 ++++++++++++++++++++++++++---------------------- package.json | 3 +- 4 files changed, 187 insertions(+), 162 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..187adb24 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/nbproject/ \ No newline at end of file diff --git a/binding.gyp b/binding.gyp index 2037c2b6..8e53c129 100644 --- a/binding.gyp +++ b/binding.gyp @@ -53,6 +53,7 @@ ], "include_dirs": [ "crypto", + " #include #include +#include extern "C" { #include "bcrypt.h" @@ -27,23 +28,22 @@ extern "C" { #include "boolberry.h" +#define THROW_ERROR_EXCEPTION(x) NanThrowError(x) +#define THROW_ERROR_EXCEPTION_WITH_STATUS_CODE(x, y) NanThrowError(x, y) + using namespace node; using namespace v8; -Handle except(const char* msg) { - return ThrowException(Exception::Error(String::New(msg))); -} - -Handle quark(const Arguments& args) { - HandleScope scope; +NAN_METHOD(quark) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -52,20 +52,21 @@ Handle quark(const Arguments& args) { quark_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle x11(const Arguments& args) { - HandleScope scope; +NAN_METHOD(x11) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -74,20 +75,21 @@ Handle x11(const Arguments& args) { x11_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle scrypt(const Arguments& args) { - HandleScope scope; +NAN_METHOD(scrypt) { + NanScope(); if (args.Length() < 3) - return except("You must provide buffer to hash, N value, and R value"); + return THROW_ERROR_EXCEPTION("You must provide buffer to hash, N value, and R value"); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); Local numn = args[1]->ToNumber(); unsigned int nValue = numn->Value(); @@ -101,22 +103,23 @@ Handle scrypt(const Arguments& args) { scrypt_N_R_1_256(input, output, nValue, rValue, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle scryptn(const Arguments& args) { - HandleScope scope; +NAN_METHOD(scryptn) { + NanScope(); if (args.Length() < 2) - return except("You must provide buffer to hash and N factor."); + return THROW_ERROR_EXCEPTION("You must provide buffer to hash and N factor."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); Local num = args[1]->ToNumber(); unsigned int nFactor = num->Value(); @@ -132,20 +135,21 @@ Handle scryptn(const Arguments& args) { scrypt_N_R_1_256(input, output, N, 1, input_len); //hardcode for now to R=1 for now - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle scryptjane(const Arguments& args) { - HandleScope scope; +NAN_METHOD(scryptjane) { + NanScope(); if (args.Length() < 5) - return except("You must provide two argument: buffer, timestamp as number, and nChainStarTime as number, nMin, and nMax"); + return THROW_ERROR_EXCEPTION("You must provide two argument: buffer, timestamp as number, and nChainStarTime as number, nMin, and nMax"); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("First should be a buffer object."); + return THROW_ERROR_EXCEPTION("First should be a buffer object."); Local num = args[1]->ToNumber(); int timestamp = num->Value(); @@ -166,20 +170,21 @@ Handle scryptjane(const Arguments& args) { scryptjane_hash(input, input_len, (uint32_t *)output, GetNfactorJane(timestamp, nChainStartTime, nMin, nMax)); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle keccak(const Arguments& args) { - HandleScope scope; +NAN_METHOD(keccak) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -188,41 +193,43 @@ Handle keccak(const Arguments& args) { keccak_hash(input, output, dSize); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle bcrypt(const Arguments& args) { - HandleScope scope; +NAN_METHOD(bcrypt) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; bcrypt_hash(input, output); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle skein(const Arguments& args) { - HandleScope scope; +NAN_METHOD(skein) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -231,21 +238,22 @@ Handle skein(const Arguments& args) { skein_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle groestl(const Arguments& args) { - HandleScope scope; +NAN_METHOD(groestl) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -254,21 +262,22 @@ Handle groestl(const Arguments& args) { groestl_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle groestlmyriad(const Arguments& args) { - HandleScope scope; +NAN_METHOD(groestlmyriad) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -277,21 +286,22 @@ Handle groestlmyriad(const Arguments& args) { groestlmyriad_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle blake(const Arguments& args) { - HandleScope scope; +NAN_METHOD(blake) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -300,21 +310,22 @@ Handle blake(const Arguments& args) { blake_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle fugue(const Arguments& args) { - HandleScope scope; +NAN_METHOD(fugue) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -323,21 +334,22 @@ Handle fugue(const Arguments& args) { fugue_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle qubit(const Arguments& args) { - HandleScope scope; +NAN_METHOD(qubit) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -346,21 +358,22 @@ Handle qubit(const Arguments& args) { qubit_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle hefty1(const Arguments& args) { - HandleScope scope; +NAN_METHOD(hefty1) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -369,21 +382,22 @@ Handle hefty1(const Arguments& args) { hefty1_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle shavite3(const Arguments& args) { - HandleScope scope; +NAN_METHOD(shavite3) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -392,28 +406,29 @@ Handle shavite3(const Arguments& args) { shavite3_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle cryptonight(const Arguments& args) { - HandleScope scope; +NAN_METHOD(cryptonight) { + NanScope(); bool fast = false; if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); if (args.Length() >= 2) { if(!args[1]->IsBoolean()) - return except("Argument 2 should be a boolean"); + return THROW_ERROR_EXCEPTION("Argument 2 should be a boolean"); fast = args[1]->ToBoolean()->BooleanValue(); } Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -425,20 +440,21 @@ Handle cryptonight(const Arguments& args) { else cryptonight_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle x13(const Arguments& args) { - HandleScope scope; +NAN_METHOD(x13) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -447,31 +463,32 @@ Handle x13(const Arguments& args) { x13_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle boolberry(const Arguments& args) { - HandleScope scope; +NAN_METHOD(boolberry) { + NanScope(); if (args.Length() < 2) - return except("You must provide two arguments."); + return THROW_ERROR_EXCEPTION("You must provide two arguments."); Local target = args[0]->ToObject(); Local target_spad = args[1]->ToObject(); uint32_t height = 1; if(!Buffer::HasInstance(target)) - return except("Argument 1 should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument 1 should be a buffer object."); if(!Buffer::HasInstance(target_spad)) - return except("Argument 2 should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument 2 should be a buffer object."); if(args.Length() >= 3) if(args[2]->IsUint32()) height = args[2]->ToUint32()->Uint32Value(); else - return except("Argument 3 should be an unsigned integer."); + return THROW_ERROR_EXCEPTION("Argument 3 should be an unsigned integer."); char * input = Buffer::Data(target); char * scratchpad = Buffer::Data(target_spad); @@ -482,20 +499,21 @@ Handle boolberry(const Arguments& args) { boolberry_hash(input, input_len, scratchpad, spad_len, output, height); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle nist5(const Arguments& args) { - HandleScope scope; +NAN_METHOD(nist5) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -504,20 +522,21 @@ Handle nist5(const Arguments& args) { nist5_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle sha1(const Arguments& args) { - HandleScope scope; +NAN_METHOD(sha1) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -526,20 +545,21 @@ Handle sha1(const Arguments& args) { sha1_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle x15(const Arguments& args) { - HandleScope scope; +NAN_METHOD(x15) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -548,20 +568,21 @@ Handle x15(const Arguments& args) { x15_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } -Handle fresh(const Arguments& args) { - HandleScope scope; +NAN_METHOD(fresh) { + NanScope(); if (args.Length() < 1) - return except("You must provide one argument."); + return THROW_ERROR_EXCEPTION("You must provide one argument."); Local target = args[0]->ToObject(); if(!Buffer::HasInstance(target)) - return except("Argument should be a buffer object."); + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); char * input = Buffer::Data(target); char output[32]; @@ -570,33 +591,34 @@ Handle fresh(const Arguments& args) { fresh_hash(input, output, input_len); - Buffer* buff = Buffer::New(output, 32); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output, 32) + ); } void init(Handle exports) { - exports->Set(String::NewSymbol("quark"), FunctionTemplate::New(quark)->GetFunction()); - exports->Set(String::NewSymbol("x11"), FunctionTemplate::New(x11)->GetFunction()); - exports->Set(String::NewSymbol("scrypt"), FunctionTemplate::New(scrypt)->GetFunction()); - exports->Set(String::NewSymbol("scryptn"), FunctionTemplate::New(scryptn)->GetFunction()); - exports->Set(String::NewSymbol("scryptjane"), FunctionTemplate::New(scryptjane)->GetFunction()); - exports->Set(String::NewSymbol("keccak"), FunctionTemplate::New(keccak)->GetFunction()); - exports->Set(String::NewSymbol("bcrypt"), FunctionTemplate::New(bcrypt)->GetFunction()); - exports->Set(String::NewSymbol("skein"), FunctionTemplate::New(skein)->GetFunction()); - exports->Set(String::NewSymbol("groestl"), FunctionTemplate::New(groestl)->GetFunction()); - exports->Set(String::NewSymbol("groestlmyriad"), FunctionTemplate::New(groestlmyriad)->GetFunction()); - exports->Set(String::NewSymbol("blake"), FunctionTemplate::New(blake)->GetFunction()); - exports->Set(String::NewSymbol("fugue"), FunctionTemplate::New(fugue)->GetFunction()); - exports->Set(String::NewSymbol("qubit"), FunctionTemplate::New(qubit)->GetFunction()); - exports->Set(String::NewSymbol("hefty1"), FunctionTemplate::New(hefty1)->GetFunction()); - exports->Set(String::NewSymbol("shavite3"), FunctionTemplate::New(shavite3)->GetFunction()); - exports->Set(String::NewSymbol("cryptonight"), FunctionTemplate::New(cryptonight)->GetFunction()); - exports->Set(String::NewSymbol("x13"), FunctionTemplate::New(x13)->GetFunction()); - exports->Set(String::NewSymbol("boolberry"), FunctionTemplate::New(boolberry)->GetFunction()); - exports->Set(String::NewSymbol("nist5"), FunctionTemplate::New(nist5)->GetFunction()); - exports->Set(String::NewSymbol("sha1"), FunctionTemplate::New(sha1)->GetFunction()); - exports->Set(String::NewSymbol("x15"), FunctionTemplate::New(x15)->GetFunction()); - exports->Set(String::NewSymbol("fresh"), FunctionTemplate::New(fresh)->GetFunction()); + exports->Set(NanNew("quark"), NanNew(quark)->GetFunction()); + exports->Set(NanNew("x11"), NanNew(x11)->GetFunction()); + exports->Set(NanNew("scrypt"), NanNew(scrypt)->GetFunction()); + exports->Set(NanNew("scryptn"), NanNew(scryptn)->GetFunction()); + exports->Set(NanNew("scryptjane"), NanNew(scryptjane)->GetFunction()); + exports->Set(NanNew("keccak"), NanNew(keccak)->GetFunction()); + exports->Set(NanNew("bcrypt"), NanNew(bcrypt)->GetFunction()); + exports->Set(NanNew("skein"), NanNew(skein)->GetFunction()); + exports->Set(NanNew("groestl"), NanNew(groestl)->GetFunction()); + exports->Set(NanNew("groestlmyriad"), NanNew(groestlmyriad)->GetFunction()); + exports->Set(NanNew("blake"), NanNew(blake)->GetFunction()); + exports->Set(NanNew("fugue"), NanNew(fugue)->GetFunction()); + exports->Set(NanNew("qubit"), NanNew(qubit)->GetFunction()); + exports->Set(NanNew("hefty1"), NanNew(hefty1)->GetFunction()); + exports->Set(NanNew("shavite3"), NanNew(shavite3)->GetFunction()); + exports->Set(NanNew("cryptonight"), NanNew(cryptonight)->GetFunction()); + exports->Set(NanNew("x13"), NanNew(x13)->GetFunction()); + exports->Set(NanNew("boolberry"), NanNew(boolberry)->GetFunction()); + exports->Set(NanNew("nist5"), NanNew(nist5)->GetFunction()); + exports->Set(NanNew("sha1"), NanNew(sha1)->GetFunction()); + exports->Set(NanNew("x15"), NanNew(x15)->GetFunction()); + exports->Set(NanNew("fresh"), NanNew(fresh)->GetFunction()); } NODE_MODULE(multihashing, init) diff --git a/package.json b/package.json index 86b07c85..636d1123 100644 --- a/package.json +++ b/package.json @@ -11,7 +11,8 @@ "url": "https://github.com/zone117x/node-multi-hashing.git" }, "dependencies" : { - "bindings" : "*" + "bindings" : "*", + "nan" : "*" }, "keywords": [ "scrypt", From fbceb712041de0ae56b299b17f57d38f0ccc95f3 Mon Sep 17 00:00:00 2001 From: clintar Date: Wed, 19 Aug 2015 00:10:47 -0600 Subject: [PATCH 2/4] Nan 2.0 changed api. Set required Nan version to 1 --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 636d1123..65db8166 100644 --- a/package.json +++ b/package.json @@ -12,7 +12,7 @@ }, "dependencies" : { "bindings" : "*", - "nan" : "*" + "nan" : "1" }, "keywords": [ "scrypt", From 4220ece9a53b0d0d669c0145fa9eddc356712393 Mon Sep 17 00:00:00 2001 From: clintar Date: Wed, 11 Nov 2015 18:07:50 -0700 Subject: [PATCH 3/4] updates for Nan 2.x --- multihashing.cc | 279 ++++++++++++++++++++++-------------------------- package.json | 2 +- 2 files changed, 131 insertions(+), 150 deletions(-) diff --git a/multihashing.cc b/multihashing.cc index d92afbee..784e6090 100644 --- a/multihashing.cc +++ b/multihashing.cc @@ -28,19 +28,21 @@ extern "C" { #include "boolberry.h" -#define THROW_ERROR_EXCEPTION(x) NanThrowError(x) -#define THROW_ERROR_EXCEPTION_WITH_STATUS_CODE(x, y) NanThrowError(x, y) +#define THROW_ERROR_EXCEPTION(x) Nan::ThrowError(x) + +void callback(char* data, void* hint) { + free(data); +} using namespace node; using namespace v8; NAN_METHOD(quark) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -52,18 +54,17 @@ NAN_METHOD(quark) { quark_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(x11) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -75,25 +76,24 @@ NAN_METHOD(x11) { x11_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(scrypt) { - NanScope(); - if (args.Length() < 3) + if (info.Length() < 3) return THROW_ERROR_EXCEPTION("You must provide buffer to hash, N value, and R value"); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); - Local numn = args[1]->ToNumber(); + Local numn = info[1]->ToNumber(); unsigned int nValue = numn->Value(); - Local numr = args[2]->ToNumber(); + Local numr = info[2]->ToNumber(); unsigned int rValue = numr->Value(); char * input = Buffer::Data(target); @@ -103,25 +103,24 @@ NAN_METHOD(scrypt) { scrypt_N_R_1_256(input, output, nValue, rValue, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(scryptn) { - NanScope(); - if (args.Length() < 2) + if (info.Length() < 2) return THROW_ERROR_EXCEPTION("You must provide buffer to hash and N factor."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); - Local num = args[1]->ToNumber(); + Local num = info[1]->ToNumber(); unsigned int nFactor = num->Value(); char * input = Buffer::Data(target); @@ -135,32 +134,31 @@ NAN_METHOD(scryptn) { scrypt_N_R_1_256(input, output, N, 1, input_len); //hardcode for now to R=1 for now - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(scryptjane) { - NanScope(); - if (args.Length() < 5) + if (info.Length() < 5) return THROW_ERROR_EXCEPTION("You must provide two argument: buffer, timestamp as number, and nChainStarTime as number, nMin, and nMax"); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("First should be a buffer object."); - Local num = args[1]->ToNumber(); + Local num = info[1]->ToNumber(); int timestamp = num->Value(); - Local num2 = args[2]->ToNumber(); + Local num2 = info[2]->ToNumber(); int nChainStartTime = num2->Value(); - Local num3 = args[3]->ToNumber(); + Local num3 = info[3]->ToNumber(); int nMin = num3->Value(); - Local num4 = args[4]->ToNumber(); + Local num4 = info[4]->ToNumber(); int nMax = num4->Value(); char * input = Buffer::Data(target); @@ -170,18 +168,17 @@ NAN_METHOD(scryptjane) { scryptjane_hash(input, input_len, (uint32_t *)output, GetNfactorJane(timestamp, nChainStartTime, nMin, nMax)); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(keccak) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -193,19 +190,18 @@ NAN_METHOD(keccak) { keccak_hash(input, output, dSize); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(bcrypt) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -215,18 +211,17 @@ NAN_METHOD(bcrypt) { bcrypt_hash(input, output); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(skein) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -238,19 +233,18 @@ NAN_METHOD(skein) { skein_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(groestl) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -262,19 +256,18 @@ NAN_METHOD(groestl) { groestl_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(groestlmyriad) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -286,19 +279,18 @@ NAN_METHOD(groestlmyriad) { groestlmyriad_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(blake) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -310,19 +302,18 @@ NAN_METHOD(blake) { blake_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(fugue) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -334,19 +325,18 @@ NAN_METHOD(fugue) { fugue_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(qubit) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -358,19 +348,18 @@ NAN_METHOD(qubit) { qubit_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(hefty1) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -382,19 +371,18 @@ NAN_METHOD(hefty1) { hefty1_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(shavite3) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -406,26 +394,25 @@ NAN_METHOD(shavite3) { shavite3_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(cryptonight) { - NanScope(); bool fast = false; - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - if (args.Length() >= 2) { - if(!args[1]->IsBoolean()) + if (info.Length() >= 2) { + if(!info[1]->IsBoolean()) return THROW_ERROR_EXCEPTION("Argument 2 should be a boolean"); - fast = args[1]->ToBoolean()->BooleanValue(); + fast = info[1]->ToBoolean()->BooleanValue(); } - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -440,18 +427,17 @@ NAN_METHOD(cryptonight) { else cryptonight_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(x13) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -463,19 +449,18 @@ NAN_METHOD(x13) { x13_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(boolberry) { - NanScope(); - if (args.Length() < 2) + if (info.Length() < 2) return THROW_ERROR_EXCEPTION("You must provide two arguments."); - Local target = args[0]->ToObject(); - Local target_spad = args[1]->ToObject(); + Local target = info[0]->ToObject(); + Local target_spad = info[1]->ToObject(); uint32_t height = 1; if(!Buffer::HasInstance(target)) @@ -484,9 +469,9 @@ NAN_METHOD(boolberry) { if(!Buffer::HasInstance(target_spad)) return THROW_ERROR_EXCEPTION("Argument 2 should be a buffer object."); - if(args.Length() >= 3) - if(args[2]->IsUint32()) - height = args[2]->ToUint32()->Uint32Value(); + if(info.Length() >= 3) + if(info[2]->IsUint32()) + height = info[2]->ToUint32()->Uint32Value(); else return THROW_ERROR_EXCEPTION("Argument 3 should be an unsigned integer."); @@ -499,18 +484,17 @@ NAN_METHOD(boolberry) { boolberry_hash(input, input_len, scratchpad, spad_len, output, height); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(nist5) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -522,18 +506,17 @@ NAN_METHOD(nist5) { nist5_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(sha1) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -545,18 +528,17 @@ NAN_METHOD(sha1) { sha1_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(x15) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -568,18 +550,17 @@ NAN_METHOD(x15) { x15_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } NAN_METHOD(fresh) { - NanScope(); - if (args.Length() < 1) + if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); - Local target = args[0]->ToObject(); + Local target = info[0]->ToObject(); if(!Buffer::HasInstance(target)) return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); @@ -591,34 +572,34 @@ NAN_METHOD(fresh) { fresh_hash(input, output, input_len); - NanReturnValue( - NanNewBufferHandle(output, 32) + info.GetReturnValue().Set( + Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() ); } -void init(Handle exports) { - exports->Set(NanNew("quark"), NanNew(quark)->GetFunction()); - exports->Set(NanNew("x11"), NanNew(x11)->GetFunction()); - exports->Set(NanNew("scrypt"), NanNew(scrypt)->GetFunction()); - exports->Set(NanNew("scryptn"), NanNew(scryptn)->GetFunction()); - exports->Set(NanNew("scryptjane"), NanNew(scryptjane)->GetFunction()); - exports->Set(NanNew("keccak"), NanNew(keccak)->GetFunction()); - exports->Set(NanNew("bcrypt"), NanNew(bcrypt)->GetFunction()); - exports->Set(NanNew("skein"), NanNew(skein)->GetFunction()); - exports->Set(NanNew("groestl"), NanNew(groestl)->GetFunction()); - exports->Set(NanNew("groestlmyriad"), NanNew(groestlmyriad)->GetFunction()); - exports->Set(NanNew("blake"), NanNew(blake)->GetFunction()); - exports->Set(NanNew("fugue"), NanNew(fugue)->GetFunction()); - exports->Set(NanNew("qubit"), NanNew(qubit)->GetFunction()); - exports->Set(NanNew("hefty1"), NanNew(hefty1)->GetFunction()); - exports->Set(NanNew("shavite3"), NanNew(shavite3)->GetFunction()); - exports->Set(NanNew("cryptonight"), NanNew(cryptonight)->GetFunction()); - exports->Set(NanNew("x13"), NanNew(x13)->GetFunction()); - exports->Set(NanNew("boolberry"), NanNew(boolberry)->GetFunction()); - exports->Set(NanNew("nist5"), NanNew(nist5)->GetFunction()); - exports->Set(NanNew("sha1"), NanNew(sha1)->GetFunction()); - exports->Set(NanNew("x15"), NanNew(x15)->GetFunction()); - exports->Set(NanNew("fresh"), NanNew(fresh)->GetFunction()); +NAN_MODULE_INIT(init) { + Nan::Set(target, Nan::New("quark").ToLocalChecked(), Nan::GetFunction(Nan::New(quark)).ToLocalChecked()); + Nan::Set(target, Nan::New("x11").ToLocalChecked(), Nan::GetFunction(Nan::New(x11)).ToLocalChecked()); + Nan::Set(target, Nan::New("scrypt").ToLocalChecked(), Nan::GetFunction(Nan::New(scrypt)).ToLocalChecked()); + Nan::Set(target, Nan::New("scryptn").ToLocalChecked(), Nan::GetFunction(Nan::New(scryptn)).ToLocalChecked()); + Nan::Set(target, Nan::New("scryptjane").ToLocalChecked(), Nan::GetFunction(Nan::New(scryptjane)).ToLocalChecked()); + Nan::Set(target, Nan::New("keccak").ToLocalChecked(), Nan::GetFunction(Nan::New(keccak)).ToLocalChecked()); + Nan::Set(target, Nan::New("bcrypt").ToLocalChecked(), Nan::GetFunction(Nan::New(bcrypt)).ToLocalChecked()); + Nan::Set(target, Nan::New("skein").ToLocalChecked(), Nan::GetFunction(Nan::New(skein)).ToLocalChecked()); + Nan::Set(target, Nan::New("groestl").ToLocalChecked(), Nan::GetFunction(Nan::New(groestl)).ToLocalChecked()); + Nan::Set(target, Nan::New("groestlmyriad").ToLocalChecked(), Nan::GetFunction(Nan::New(groestlmyriad)).ToLocalChecked()); + Nan::Set(target, Nan::New("blake").ToLocalChecked(), Nan::GetFunction(Nan::New(blake)).ToLocalChecked()); + Nan::Set(target, Nan::New("fugue").ToLocalChecked(), Nan::GetFunction(Nan::New(fugue)).ToLocalChecked()); + Nan::Set(target, Nan::New("qubit").ToLocalChecked(), Nan::GetFunction(Nan::New(qubit)).ToLocalChecked()); + Nan::Set(target, Nan::New("hefty1").ToLocalChecked(), Nan::GetFunction(Nan::New(hefty1)).ToLocalChecked()); + Nan::Set(target, Nan::New("shavite3").ToLocalChecked(), Nan::GetFunction(Nan::New(shavite3)).ToLocalChecked()); + Nan::Set(target, Nan::New("cryptonight").ToLocalChecked(), Nan::GetFunction(Nan::New(cryptonight)).ToLocalChecked()); + Nan::Set(target, Nan::New("x13").ToLocalChecked(), Nan::GetFunction(Nan::New(x13)).ToLocalChecked()); + Nan::Set(target, Nan::New("boolberry").ToLocalChecked(), Nan::GetFunction(Nan::New(boolberry)).ToLocalChecked()); + Nan::Set(target, Nan::New("nist5").ToLocalChecked(), Nan::GetFunction(Nan::New(nist5)).ToLocalChecked()); + Nan::Set(target, Nan::New("sha1").ToLocalChecked(), Nan::GetFunction(Nan::New(sha1)).ToLocalChecked()); + Nan::Set(target, Nan::New("x15").ToLocalChecked(), Nan::GetFunction(Nan::New(x15)).ToLocalChecked()); + Nan::Set(target, Nan::New("fresh").ToLocalChecked(), Nan::GetFunction(Nan::New(fresh)).ToLocalChecked()); } NODE_MODULE(multihashing, init) diff --git a/package.json b/package.json index 65db8166..3b513712 100644 --- a/package.json +++ b/package.json @@ -12,7 +12,7 @@ }, "dependencies" : { "bindings" : "*", - "nan" : "1" + "nan": "^2.0.0" }, "keywords": [ "scrypt", From 6df2cd104c0dcc5dceea216c1fcadbbbd0986552 Mon Sep 17 00:00:00 2001 From: clintar Date: Wed, 11 Nov 2015 20:03:55 -0700 Subject: [PATCH 4/4] use copybuffer. that seems to work --- multihashing.cc | 68 ++++++++++++++++++++++++++++++++----------------- 1 file changed, 45 insertions(+), 23 deletions(-) diff --git a/multihashing.cc b/multihashing.cc index 784e6090..f3f337d0 100644 --- a/multihashing.cc +++ b/multihashing.cc @@ -54,8 +54,9 @@ NAN_METHOD(quark) { quark_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -76,8 +77,9 @@ NAN_METHOD(x11) { x11_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -103,8 +105,9 @@ NAN_METHOD(scrypt) { scrypt_N_R_1_256(input, output, nValue, rValue, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -134,8 +137,9 @@ NAN_METHOD(scryptn) { scrypt_N_R_1_256(input, output, N, 1, input_len); //hardcode for now to R=1 for now + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -168,8 +172,9 @@ NAN_METHOD(scryptjane) { scryptjane_hash(input, input_len, (uint32_t *)output, GetNfactorJane(timestamp, nChainStartTime, nMin, nMax)); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -190,8 +195,9 @@ NAN_METHOD(keccak) { keccak_hash(input, output, dSize); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -211,8 +217,9 @@ NAN_METHOD(bcrypt) { bcrypt_hash(input, output); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -233,8 +240,9 @@ NAN_METHOD(skein) { skein_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -256,8 +264,9 @@ NAN_METHOD(groestl) { groestl_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -279,8 +288,9 @@ NAN_METHOD(groestlmyriad) { groestlmyriad_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -302,8 +312,9 @@ NAN_METHOD(blake) { blake_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -325,8 +336,9 @@ NAN_METHOD(fugue) { fugue_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -348,8 +360,9 @@ NAN_METHOD(qubit) { qubit_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -371,8 +384,9 @@ NAN_METHOD(hefty1) { hefty1_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -394,8 +408,9 @@ NAN_METHOD(shavite3) { shavite3_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -427,8 +442,9 @@ NAN_METHOD(cryptonight) { else cryptonight_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -449,8 +465,9 @@ NAN_METHOD(x13) { x13_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -483,10 +500,11 @@ NAN_METHOD(boolberry) { uint64_t spad_len = Buffer::Length(target_spad); boolberry_hash(input, input_len, scratchpad, spad_len, output, height); - + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); + } NAN_METHOD(nist5) { @@ -506,8 +524,9 @@ NAN_METHOD(nist5) { nist5_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -528,8 +547,9 @@ NAN_METHOD(sha1) { sha1_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -550,8 +570,9 @@ NAN_METHOD(x15) { x15_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); } @@ -572,8 +593,9 @@ NAN_METHOD(fresh) { fresh_hash(input, output, input_len); + v8::Local returnValue = Nan::CopyBuffer(output, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(output, 32,callback,0).ToLocalChecked() + returnValue ); }