Bitmessage/bitmessage-js
2
0
Fork 1
Code Issues 1 Pull Requests 1 Actions Packages Releases Activity

Fix for latest nan and eccrypto

Browse Source 
Fixes #17
This commit is contained in:
Kagami Hiiragi 2015-11-13 21:32:32 +03:00
parent 4c184c2a25
commit 8310ff1a9c
2 changed files with 26 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
package.json
View File

@ -50,10 +50,10 @@
"bn.js": "^3.0.1", "bn.js": "^3.0.1",
"bs58": "^2.0.0", "bs58": "^2.0.0",
"buffer-equal": "~0.0.1", "buffer-equal": "~0.0.1",
"eccrypto": "^1.0.1", "eccrypto": "^1.0.3",
"es6-promise": "^2.0.1", "es6-promise": "^3.0.2",
"hash.js": "^1.0.2", "hash.js": "^1.0.2",
"nan": "^1.4.1", "nan": "^2.1.0",
"object-assign": "^2.0.0", "object-assign": "^2.0.0",
"sha.js": "^2.3.1", "sha.js": "^2.3.1",
"webworkify": "^1.0.1" "webworkify": "^1.0.1"

51
src/worker.cc
View File

@ -13,13 +13,13 @@ using v8::Number;
static const uint64_t MAX_SAFE_INTEGER = 9007199254740991ULL; static const uint64_t MAX_SAFE_INTEGER = 9007199254740991ULL;
class PowWorker : public NanAsyncWorker { class PowWorker : public Nan::AsyncWorker {
public: public:
PowWorker(NanCallback* callback, PowWorker(Nan::Callback* callback,
size_t pool_size, size_t pool_size,
uint64_t target, uint64_t target,
uint8_t* initial_hash) uint8_t* initial_hash)
: NanAsyncWorker(callback), : Nan::AsyncWorker(callback),
pool_size(pool_size), pool_size(pool_size),
target(target), target(target),
initial_hash(initial_hash) {} initial_hash(initial_hash) {}
@ -40,17 +40,16 @@ class PowWorker : public NanAsyncWorker {
// this function will be run inside the main event loop // this function will be run inside the main event loop
// so it is safe to use V8 again // so it is safe to use V8 again
void HandleOKCallback () { void HandleOKCallback () {
NanScope();
if (error) { if (error) {
Local<Value> argv[1]; Local<Value> argv[1];
if (error == -1) { if (error == -1) {
argv[0] = NanError("Max safe integer overflow"); argv[0] = Nan::Error("Max safe integer overflow");
} else { } else {
argv[0] = NanError("Internal error"); argv[0] = Nan::Error("Internal error");
} }
callback->Call(1, argv); callback->Call(1, argv);
} else { } else {
Local<Value> argv[] = {NanNull(), NanNew<Number>(nonce)}; Local<Value> argv[] = {Nan::Null(), Nan::New<Number>(nonce)};
callback->Call(2, argv); callback->Call(2, argv);
} }
} }
@ -64,39 +63,35 @@ class PowWorker : public NanAsyncWorker {
}; };
NAN_METHOD(PowAsync) { NAN_METHOD(PowAsync) {
NanScope(); if (info.Length() != 4 ||
!info[0]->IsNumber() || // pool_size
if (args.Length() != 4 || !info[1]->IsNumber() || // target
!args[0]->IsNumber() || // pool_size !node::Buffer::HasInstance(info[2]) || // initial_hash
!args[1]->IsNumber() || // target !info[3]->IsFunction()) { // cb
!node::Buffer::HasInstance(args[2]) || // initial_hash return Nan::ThrowError("Bad input");
!args[3]->IsFunction()) { // cb
return NanThrowError("Bad input");
} }
size_t pool_size = args[0]->Uint32Value(); size_t pool_size = info[0]->Uint32Value();
uint64_t target = args[1]->IntegerValue(); uint64_t target = info[1]->IntegerValue();
char* buf = node::Buffer::Data(args[2]); char* buf = node::Buffer::Data(info[2]);
size_t length = node::Buffer::Length(args[2]); size_t length = node::Buffer::Length(info[2]);
if (pool_size < 1 || if (pool_size < 1 ||
pool_size > MAX_POOL_SIZE || pool_size > MAX_POOL_SIZE ||
buf == NULL || buf == NULL ||
length != HASH_SIZE) { length != HASH_SIZE) {
return NanThrowError("Bad input"); return Nan::ThrowError("Bad input");
} }
// TODO(Kagami): Do we need to process `std::bad_alloc`?
uint8_t* initial_hash = new uint8_t[length]; uint8_t* initial_hash = new uint8_t[length];
memcpy(initial_hash, buf, length); memcpy(initial_hash, buf, length);
NanCallback* callback = new NanCallback(args[3].As<Function>()); Nan::Callback* callback = new Nan::Callback(info[3].As<Function>());
NanAsyncQueueWorker(new PowWorker(callback, pool_size, target, initial_hash)); Nan::AsyncQueueWorker(
NanReturnUndefined(); new PowWorker(callback, pool_size, target, initial_hash));
} }
void InitAll(Handle<Object> exports) { NAN_MODULE_INIT(InitAll) {
exports->Set( Nan::Set(target, Nan::New<String>("powAsync").ToLocalChecked(),
NanNew<String>("powAsync"), Nan::GetFunction(Nan::New<FunctionTemplate>(PowAsync)).ToLocalChecked());
NanNew<FunctionTemplate>(PowAsync)->GetFunction());
} }
NODE_MODULE(worker, InitAll) NODE_MODULE(worker, InitAll)