From d5d0965c5478c12f7738a1fe02863b49b6100384 Mon Sep 17 00:00:00 2001 From: clintar Date: Fri, 10 Apr 2015 14:06:36 -0600 Subject: [PATCH 01/11] 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 + package.json | 3 +- src/main.cc | 110 ++++++++++++++++++++++++++------------------------- 4 files changed, 61 insertions(+), 54 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 50b9802a..1ecc104f 100644 --- a/binding.gyp +++ b/binding.gyp @@ -16,6 +16,7 @@ "include_dirs": [ "src", "src/contrib/epee/include", + " +#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; using namespace cryptonote; -Handle except(const char* msg) { - return ThrowException(Exception::Error(String::New(msg))); -} - blobdata uint64be_to_blob(uint64_t num) { blobdata res = " "; res[0] = num >> 56 & 0xff; @@ -77,16 +77,16 @@ static bool construct_parent_block(const cryptonote::block& b, cryptonote::block return fillExtra(parent_block, b); } -Handle convert_blob(const Arguments& args) { - HandleScope scope; +NAN_METHOD(convert_blob) { + 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."); blobdata input = std::string(Buffer::Data(target), Buffer::Length(target)); blobdata output = ""; @@ -94,64 +94,66 @@ Handle convert_blob(const Arguments& args) { //convert block b = AUTO_VAL_INIT(b); if (!parse_and_validate_block_from_blob(input, b)) - return except("Failed to parse block"); + return THROW_ERROR_EXCEPTION("Failed to parse block"); if (b.major_version < BLOCK_MAJOR_VERSION_2) { if (!get_block_hashing_blob(b, output)) - return except("Failed to create mining block"); + return THROW_ERROR_EXCEPTION("Failed to create mining block"); } else { block parent_block; if (!construct_parent_block(b, parent_block)) - return except("Failed to construct parent block"); + return THROW_ERROR_EXCEPTION("Failed to construct parent block"); if (!get_block_hashing_blob(parent_block, output)) - return except("Failed to create mining block"); + return THROW_ERROR_EXCEPTION("Failed to create mining block"); } - Buffer* buff = Buffer::New(output.data(), output.size()); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output.data(), output.size()) + ); } -Handle get_block_id(const Arguments& args) { - HandleScope scope; +NAN_METHOD(get_block_id) { + 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."); blobdata input = std::string(Buffer::Data(target), Buffer::Length(target)); blobdata output = ""; block b = AUTO_VAL_INIT(b); if (!parse_and_validate_block_from_blob(input, b)) - return except("Failed to parse block"); + return THROW_ERROR_EXCEPTION("Failed to parse block"); crypto::hash block_id; if (!get_block_hash(b, block_id)) - return except("Failed to calculate hash for block"); + return THROW_ERROR_EXCEPTION("Failed to calculate hash for block"); - Buffer* buff = Buffer::New(reinterpret_cast(&block_id), sizeof(block_id)); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(reinterpret_cast(&block_id), sizeof(block_id)) + ); } -Handle construct_block_blob(const Arguments& args) { - HandleScope scope; +NAN_METHOD(construct_block_blob) { + NanScope(); if (args.Length() < 2) - return except("You must provide two arguments."); + return THROW_ERROR_EXCEPTION("You must provide two arguments."); Local block_template_buf = args[0]->ToObject(); Local nonce_buf = args[1]->ToObject(); if (!Buffer::HasInstance(block_template_buf) || !Buffer::HasInstance(nonce_buf)) - return except("Both arguments should be buffer objects."); + return THROW_ERROR_EXCEPTION("Both arguments should be buffer objects."); if (Buffer::Length(nonce_buf) != 4) - return except("Nonce buffer has invalid size."); + return THROW_ERROR_EXCEPTION("Nonce buffer has invalid size."); uint32_t nonce = *reinterpret_cast(Buffer::Data(nonce_buf)); @@ -160,36 +162,37 @@ Handle construct_block_blob(const Arguments& args) { block b = AUTO_VAL_INIT(b); if (!parse_and_validate_block_from_blob(block_template_blob, b)) - return except("Failed to parse block"); + return THROW_ERROR_EXCEPTION("Failed to parse block"); b.nonce = nonce; if (b.major_version == BLOCK_MAJOR_VERSION_2) { block parent_block; b.parent_block.nonce = nonce; if (!construct_parent_block(b, parent_block)) - return except("Failed to construct parent block"); + return THROW_ERROR_EXCEPTION("Failed to construct parent block"); if (!mergeBlocks(parent_block, b, std::vector())) - return except("Failed to postprocess mining block"); + return THROW_ERROR_EXCEPTION("Failed to postprocess mining block"); } if (!block_to_blob(b, output)) - return except("Failed to convert block to blob"); + return THROW_ERROR_EXCEPTION("Failed to convert block to blob"); - Buffer* buff = Buffer::New(output.data(), output.size()); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output.data(), output.size()) + ); } -Handle convert_blob_bb(const Arguments& args) { - HandleScope scope; +NAN_METHOD(convert_blob_bb) { + 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."); blobdata input = std::string(Buffer::Data(target), Buffer::Length(target)); blobdata output = ""; @@ -197,48 +200,49 @@ Handle convert_blob_bb(const Arguments& args) { //convert bb_block b = AUTO_VAL_INIT(b); if (!parse_and_validate_block_from_blob(input, b)) { - return except("Failed to parse block"); + return THROW_ERROR_EXCEPTION("Failed to parse block"); } output = get_block_hashing_blob(b); - Buffer* buff = Buffer::New(output.data(), output.size()); - return scope.Close(buff->handle_); + NanReturnValue( + NanNewBufferHandle(output.data(), output.size()) + ); } -Handle address_decode(const Arguments& args) { - HandleScope scope; +NAN_METHOD(address_decode) { + NanEscapableScope(); 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."); blobdata input = std::string(Buffer::Data(target), Buffer::Length(target)); blobdata data; uint64_t prefix; if (!tools::base58::decode_addr(input, prefix, data)) - return scope.Close(Undefined()); + NanReturnUndefined(); account_public_address adr; if (!::serialization::parse_binary(data, adr)) - return scope.Close(Undefined()); + NanReturnUndefined(); if (!crypto::check_key(adr.m_spend_public_key) || !crypto::check_key(adr.m_view_public_key)) - return scope.Close(Undefined()); + NanReturnUndefined(); - return scope.Close(Integer::New(static_cast(prefix))); + NanReturnValue(NanNew(static_cast(prefix))); } void init(Handle exports) { - exports->Set(String::NewSymbol("construct_block_blob"), FunctionTemplate::New(construct_block_blob)->GetFunction()); - exports->Set(String::NewSymbol("get_block_id"), FunctionTemplate::New(get_block_id)->GetFunction()); - exports->Set(String::NewSymbol("convert_blob"), FunctionTemplate::New(convert_blob)->GetFunction()); - exports->Set(String::NewSymbol("convert_blob_bb"), FunctionTemplate::New(convert_blob_bb)->GetFunction()); - exports->Set(String::NewSymbol("address_decode"), FunctionTemplate::New(address_decode)->GetFunction()); + exports->Set(NanNew("construct_block_blob"), NanNew(construct_block_blob)->GetFunction()); + exports->Set(NanNew("get_block_id"), NanNew(get_block_id)->GetFunction()); + exports->Set(NanNew("convert_blob"), NanNew(convert_blob)->GetFunction()); + exports->Set(NanNew("convert_blob_bb"), NanNew(convert_blob_bb)->GetFunction()); + exports->Set(NanNew("address_decode"), NanNew(address_decode)->GetFunction()); } NODE_MODULE(cryptonote, init) From eefe9b790f4f81669c7ee0043c5fcba9e77fca39 Mon Sep 17 00:00:00 2001 From: clintar Date: Wed, 19 Aug 2015 00:13:19 -0600 Subject: [PATCH 02/11] 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 fc158d03..697206d6 100644 --- a/package.json +++ b/package.json @@ -12,7 +12,7 @@ }, "dependencies" : { "bindings" : "*", - "nan" : "*" + "nan" : "1" }, "keywords": [ "cryptonight", From da133cd3849529e64e564ff18422f6b52516738c Mon Sep 17 00:00:00 2001 From: clintar Date: Wed, 11 Nov 2015 19:24:47 -0700 Subject: [PATCH 03/11] updates for Nan 2.x --- package.json | 38 ++++++++++---------- src/main.cc | 97 +++++++++++++++++++++++++++++----------------------- 2 files changed, 73 insertions(+), 62 deletions(-) diff --git a/package.json b/package.json index 697206d6..bef4d713 100644 --- a/package.json +++ b/package.json @@ -1,21 +1,21 @@ { - "name": "cryptonote-util", - "version": "0.0.1", - "main": "cryptonote", - "author": { - "name": "LucasJones", - "email": "lucasjonesdev@hotmail.co.uk" - }, - "repository": { - "type": "git", - "url": "https://github.com/LucasJones/node-cryptonote-util.git" - }, - "dependencies" : { - "bindings" : "*", - "nan" : "1" - }, - "keywords": [ - "cryptonight", - "cryptonote" - ] + "name": "cryptonote-util", + "version": "0.0.1", + "main": "cryptonote", + "author": { + "name": "LucasJones", + "email": "lucasjonesdev@hotmail.co.uk" + }, + "repository": { + "type": "git", + "url": "https://github.com/clintar/node-cryptonote-util.git" + }, + "dependencies": { + "bindings": "*", + "nan": "^2.0.0" + }, + "keywords": [ + "cryptonight", + "cryptonote" + ] } diff --git a/src/main.cc b/src/main.cc index 13bd3452..c58a1eac 100644 --- a/src/main.cc +++ b/src/main.cc @@ -14,9 +14,12 @@ #include "serialization/binary_utils.h" #include -#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; using namespace cryptonote; @@ -78,12 +81,11 @@ static bool construct_parent_block(const cryptonote::block& b, cryptonote::block } NAN_METHOD(convert_blob) { - 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."); @@ -107,19 +109,24 @@ NAN_METHOD(convert_blob) { if (!get_block_hashing_blob(parent_block, output)) return THROW_ERROR_EXCEPTION("Failed to create mining block"); } - - NanReturnValue( - NanNewBufferHandle(output.data(), output.size()) +// Local v8::Local returnValue = Nan::NewBuffer(output.length()).ToLocalChecked(); +// memcpy(Buffer::Data(returnValue), output.c_str(), output.length()); +// info.GetReturnValue().Set( +// returnValue +// ); + + v8::Local returnValue = Nan::CopyBuffer((char*)output.data(), output.size()).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue ); } -NAN_METHOD(get_block_id) { - NanScope(); +void get_block_id(const Nan::FunctionCallbackInfo& info) { - 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."); @@ -134,20 +141,20 @@ NAN_METHOD(get_block_id) { crypto::hash block_id; if (!get_block_hash(b, block_id)) return THROW_ERROR_EXCEPTION("Failed to calculate hash for block"); - - NanReturnValue( - NanNewBufferHandle(reinterpret_cast(&block_id), sizeof(block_id)) + + char *cstr = reinterpret_cast(&block_id); + info.GetReturnValue().Set( + Nan::NewBuffer(cstr, 32, callback,0).ToLocalChecked() ); } -NAN_METHOD(construct_block_blob) { - NanScope(); +void construct_block_blob(const Nan::FunctionCallbackInfo& info) { - if (args.Length() < 2) + if (info.Length() < 2) return THROW_ERROR_EXCEPTION("You must provide two arguments."); - Local block_template_buf = args[0]->ToObject(); - Local nonce_buf = args[1]->ToObject(); + Local block_template_buf = info[0]->ToObject(); + Local nonce_buf = info[1]->ToObject(); if (!Buffer::HasInstance(block_template_buf) || !Buffer::HasInstance(nonce_buf)) return THROW_ERROR_EXCEPTION("Both arguments should be buffer objects."); @@ -178,18 +185,18 @@ NAN_METHOD(construct_block_blob) { if (!block_to_blob(b, output)) return THROW_ERROR_EXCEPTION("Failed to convert block to blob"); - NanReturnValue( - NanNewBufferHandle(output.data(), output.size()) + v8::Local returnValue = Nan::CopyBuffer((char*)output.data(), output.size()).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue ); } -NAN_METHOD(convert_blob_bb) { - NanScope(); +void convert_blob_bb(const Nan::FunctionCallbackInfo& info) { - 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."); @@ -204,18 +211,18 @@ NAN_METHOD(convert_blob_bb) { } output = get_block_hashing_blob(b); - NanReturnValue( - NanNewBufferHandle(output.data(), output.size()) + v8::Local returnValue = Nan::CopyBuffer((char*)output.data(), output.size()).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue ); } -NAN_METHOD(address_decode) { - NanEscapableScope(); +void address_decode(const Nan::FunctionCallbackInfo& info) { - 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."); @@ -225,24 +232,28 @@ NAN_METHOD(address_decode) { blobdata data; uint64_t prefix; if (!tools::base58::decode_addr(input, prefix, data)) - NanReturnUndefined(); + { + info.GetReturnValue().Set(Nan::Undefined()); + } + // info.GetReturnValue().Set(Nan::Undefined()); + account_public_address adr; if (!::serialization::parse_binary(data, adr)) - NanReturnUndefined(); + info.GetReturnValue().Set(Nan::Undefined()); if (!crypto::check_key(adr.m_spend_public_key) || !crypto::check_key(adr.m_view_public_key)) - NanReturnUndefined(); + info.GetReturnValue().Set(Nan::Undefined()); - NanReturnValue(NanNew(static_cast(prefix))); + info.GetReturnValue().Set(Nan::New(static_cast(prefix))); } -void init(Handle exports) { - exports->Set(NanNew("construct_block_blob"), NanNew(construct_block_blob)->GetFunction()); - exports->Set(NanNew("get_block_id"), NanNew(get_block_id)->GetFunction()); - exports->Set(NanNew("convert_blob"), NanNew(convert_blob)->GetFunction()); - exports->Set(NanNew("convert_blob_bb"), NanNew(convert_blob_bb)->GetFunction()); - exports->Set(NanNew("address_decode"), NanNew(address_decode)->GetFunction()); +NAN_MODULE_INIT(init) { + Nan::Set(target, Nan::New("construct_block_blob").ToLocalChecked(), Nan::GetFunction(Nan::New(construct_block_blob)).ToLocalChecked()); + Nan::Set(target, Nan::New("get_block_id").ToLocalChecked(), Nan::GetFunction(Nan::New(get_block_id)).ToLocalChecked()); + Nan::Set(target, Nan::New("convert_blob").ToLocalChecked(), Nan::GetFunction(Nan::New(convert_blob)).ToLocalChecked()); + Nan::Set(target, Nan::New("convert_blob_bb").ToLocalChecked(), Nan::GetFunction(Nan::New(convert_blob_bb)).ToLocalChecked()); + Nan::Set(target, Nan::New("address_decode").ToLocalChecked(), Nan::GetFunction(Nan::New(address_decode)).ToLocalChecked()); } NODE_MODULE(cryptonote, init) From 0ac11dca8b77dcc377bbdafd454d5927bc59a4fd Mon Sep 17 00:00:00 2001 From: clintar Date: Thu, 12 Nov 2015 13:42:40 -0700 Subject: [PATCH 04/11] use copybuffer --- src/main.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main.cc b/src/main.cc index c58a1eac..b9e4af1c 100644 --- a/src/main.cc +++ b/src/main.cc @@ -143,8 +143,9 @@ void get_block_id(const Nan::FunctionCallbackInfo& info) { return THROW_ERROR_EXCEPTION("Failed to calculate hash for block"); char *cstr = reinterpret_cast(&block_id); + v8::Local returnValue = Nan::CopyBuffer(cstr, 32).ToLocalChecked(); info.GetReturnValue().Set( - Nan::NewBuffer(cstr, 32, callback,0).ToLocalChecked() + returnValue ); } From 54f5563ebb250013249ace0d0c97f2b389cbb882 Mon Sep 17 00:00:00 2001 From: clintar Date: Tue, 17 Nov 2015 23:26:36 -0700 Subject: [PATCH 05/11] make compatible with standard node-cryptonote-pool --- src/main.cc | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/src/main.cc b/src/main.cc index b9e4af1c..2d1b0c44 100644 --- a/src/main.cc +++ b/src/main.cc @@ -240,13 +240,26 @@ void address_decode(const Nan::FunctionCallbackInfo& info) { account_public_address adr; - if (!::serialization::parse_binary(data, adr)) - info.GetReturnValue().Set(Nan::Undefined()); - - if (!crypto::check_key(adr.m_spend_public_key) || !crypto::check_key(adr.m_view_public_key)) - info.GetReturnValue().Set(Nan::Undefined()); + if (!::serialization::parse_binary(data, adr) || !crypto::check_key(adr.m_spend_public_key) || !crypto::check_key(adr.m_view_public_key)) + { + if(data.length()) + { + data = uint64be_to_blob(prefix) + data; + } + else + { + info.GetReturnValue().Set(Nan::Undefined()); + } + v8::Local returnValue = Nan::CopyBuffer((char*)data.data(), data.size()).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue + ); - info.GetReturnValue().Set(Nan::New(static_cast(prefix))); + } + else + { + info.GetReturnValue().Set(Nan::New(static_cast(prefix))); + } } NAN_MODULE_INIT(init) { From 81f2e15516e3704d388c8ed327d6a7129256493f Mon Sep 17 00:00:00 2001 From: clintar Date: Wed, 23 Mar 2016 16:49:58 -0600 Subject: [PATCH 06/11] since BLOCK_MAJOR_VERSION_2 is the same after xmr hardfork, create a different function for fantomcoin for now. --- src/main.cc | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/main.cc b/src/main.cc index 2d1b0c44..bdd1401c 100644 --- a/src/main.cc +++ b/src/main.cc @@ -93,6 +93,33 @@ NAN_METHOD(convert_blob) { blobdata input = std::string(Buffer::Data(target), Buffer::Length(target)); blobdata output = ""; + //convert + block b = AUTO_VAL_INIT(b); + if (!parse_and_validate_block_from_blob(input, b)) + return THROW_ERROR_EXCEPTION("Failed to parse block"); + + if (!get_block_hashing_blob(b, output)) + return THROW_ERROR_EXCEPTION("Failed to create mining block"); + + v8::Local returnValue = Nan::CopyBuffer((char*)output.data(), output.size()).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue + ); +} + +NAN_METHOD(convert_blob_fa) { + + if (info.Length() < 1) + return THROW_ERROR_EXCEPTION("You must provide one argument."); + + Local target = info[0]->ToObject(); + + if (!Buffer::HasInstance(target)) + return THROW_ERROR_EXCEPTION("Argument should be a buffer object."); + + blobdata input = std::string(Buffer::Data(target), Buffer::Length(target)); + blobdata output = ""; + //convert block b = AUTO_VAL_INIT(b); if (!parse_and_validate_block_from_blob(input, b)) From 0a259628adf3fe9ed169fef28424cf8b8a92b88c Mon Sep 17 00:00:00 2001 From: clintar Date: Thu, 24 Mar 2016 02:54:11 -0600 Subject: [PATCH 07/11] another fix since xmr hardfork version increased --- src/main.cc | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/src/main.cc b/src/main.cc index bdd1401c..617f01d8 100644 --- a/src/main.cc +++ b/src/main.cc @@ -195,6 +195,38 @@ void construct_block_blob(const Nan::FunctionCallbackInfo& info) { blobdata block_template_blob = std::string(Buffer::Data(block_template_buf), Buffer::Length(block_template_buf)); blobdata output = ""; + block b = AUTO_VAL_INIT(b); + if (!parse_and_validate_block_from_blob(block_template_blob, b)) + return THROW_ERROR_EXCEPTION("Failed to parse block"); + + if (!block_to_blob(b, output)) + return THROW_ERROR_EXCEPTION("Failed to convert block to blob"); + + v8::Local returnValue = Nan::CopyBuffer((char*)output.data(), output.size()).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue + ); +} + +void construct_block_blob_fa(const Nan::FunctionCallbackInfo& info) { + + if (info.Length() < 2) + return THROW_ERROR_EXCEPTION("You must provide two arguments."); + + Local block_template_buf = info[0]->ToObject(); + Local nonce_buf = info[1]->ToObject(); + + if (!Buffer::HasInstance(block_template_buf) || !Buffer::HasInstance(nonce_buf)) + return THROW_ERROR_EXCEPTION("Both arguments should be buffer objects."); + + if (Buffer::Length(nonce_buf) != 4) + return THROW_ERROR_EXCEPTION("Nonce buffer has invalid size."); + + uint32_t nonce = *reinterpret_cast(Buffer::Data(nonce_buf)); + + blobdata block_template_blob = std::string(Buffer::Data(block_template_buf), Buffer::Length(block_template_buf)); + blobdata output = ""; + block b = AUTO_VAL_INIT(b); if (!parse_and_validate_block_from_blob(block_template_blob, b)) return THROW_ERROR_EXCEPTION("Failed to parse block"); From 15d682bfb64a7c769d2c0a3f41361956afb055fe Mon Sep 17 00:00:00 2001 From: clintar Date: Thu, 24 Mar 2016 03:18:20 -0600 Subject: [PATCH 08/11] more fixes since xmr hardfork version increased --- src/cryptonote_core/cryptonote_basic.h | 10 ++++----- .../cryptonote_format_utils.cpp | 22 +++++++++---------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/cryptonote_core/cryptonote_basic.h b/src/cryptonote_core/cryptonote_basic.h index d59e37b7..a681a4c6 100644 --- a/src/cryptonote_core/cryptonote_basic.h +++ b/src/cryptonote_core/cryptonote_basic.h @@ -479,11 +479,11 @@ namespace cryptonote BEGIN_SERIALIZE_OBJECT() FIELDS(*static_cast(this)) - if (BLOCK_MAJOR_VERSION_2 <= major_version) - { - auto sbb = make_serializable_bytecoin_block(*this, false, false); - FIELD_N("parent_block", sbb); - } +// if (BLOCK_MAJOR_VERSION_2 <= major_version) +// { +// auto sbb = make_serializable_bytecoin_block(*this, false, false); +// FIELD_N("parent_block", sbb); +// } FIELD(miner_tx) FIELD(tx_hashes) END_SERIALIZE() diff --git a/src/cryptonote_core/cryptonote_format_utils.cpp b/src/cryptonote_core/cryptonote_format_utils.cpp index 7d8562b3..739b3b64 100644 --- a/src/cryptonote_core/cryptonote_format_utils.cpp +++ b/src/cryptonote_core/cryptonote_format_utils.cpp @@ -650,15 +650,15 @@ namespace cryptonote if (!get_block_hashing_blob(b, blob)) return false; - if (BLOCK_MAJOR_VERSION_2 <= b.major_version) - { - blobdata parent_blob; - auto sbb = make_serializable_bytecoin_block(b, true, false); - if (!t_serializable_object_to_blob(sbb, parent_blob)) - return false; +// if (BLOCK_MAJOR_VERSION_2 <= b.major_version) +// { +// blobdata parent_blob; +// auto sbb = make_serializable_bytecoin_block(b, true, false); +// if (!t_serializable_object_to_blob(sbb, parent_blob)) +// return false; - blob.append(parent_blob); - } +// blob.append(parent_blob); +// } return get_object_hash(blob, res); } @@ -851,8 +851,8 @@ namespace cryptonote //--------------------------------------------------------------- bool check_proof_of_work_v1(const block& bl, difficulty_type current_diffic, crypto::hash& proof_of_work) { - if (BLOCK_MAJOR_VERSION_1 != bl.major_version) - return false; +// if (BLOCK_MAJOR_VERSION_1 != bl.major_version) +// return false; proof_of_work = get_block_longhash(bl, 0); return check_hash(proof_of_work, current_diffic); @@ -899,7 +899,7 @@ namespace cryptonote switch (bl.major_version) { case BLOCK_MAJOR_VERSION_1: return check_proof_of_work_v1(bl, current_diffic, proof_of_work); - case BLOCK_MAJOR_VERSION_2: return check_proof_of_work_v2(bl, current_diffic, proof_of_work); + case BLOCK_MAJOR_VERSION_2: return check_proof_of_work_v1(bl, current_diffic, proof_of_work); } CHECK_AND_ASSERT_MES(false, false, "unknown block major version: " << bl.major_version << "." << bl.minor_version); From 3e9fd69c9c4373eb04cf649de253f0a307e9fd8b Mon Sep 17 00:00:00 2001 From: clintar Date: Thu, 24 Mar 2016 03:33:39 -0600 Subject: [PATCH 09/11] more fixes --- src/cryptonote_core/cryptonote_basic.h | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/src/cryptonote_core/cryptonote_basic.h b/src/cryptonote_core/cryptonote_basic.h index a681a4c6..f9e6727f 100644 --- a/src/cryptonote_core/cryptonote_basic.h +++ b/src/cryptonote_core/cryptonote_basic.h @@ -458,15 +458,9 @@ namespace cryptonote VARINT_FIELD(major_version) if(major_version > BLOCK_MAJOR_VERSION_2) return false; VARINT_FIELD(minor_version) - if (BLOCK_MAJOR_VERSION_1 == major_version) - { - VARINT_FIELD(timestamp) - } + VARINT_FIELD(timestamp) FIELD(prev_id) - if (BLOCK_MAJOR_VERSION_1 == major_version) - { - FIELD(nonce) - } + FIELD(nonce) END_SERIALIZE() }; From 8d74079e59552a00cd287fa854c79c751421634c Mon Sep 17 00:00:00 2001 From: clintar Date: Thu, 24 Mar 2016 03:48:41 -0600 Subject: [PATCH 10/11] accidentally removed nonce. need nonce --- src/main.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main.cc b/src/main.cc index 617f01d8..cf575a15 100644 --- a/src/main.cc +++ b/src/main.cc @@ -198,7 +198,7 @@ void construct_block_blob(const Nan::FunctionCallbackInfo& info) { block b = AUTO_VAL_INIT(b); if (!parse_and_validate_block_from_blob(block_template_blob, b)) return THROW_ERROR_EXCEPTION("Failed to parse block"); - + b.nonce = nonce; if (!block_to_blob(b, output)) return THROW_ERROR_EXCEPTION("Failed to convert block to blob"); From a9462e932bc0ff627dca99d57bd2b20a5b716cce Mon Sep 17 00:00:00 2001 From: clintar Date: Fri, 10 Aug 2018 16:14:01 -0600 Subject: [PATCH 11/11] Fix new gcc compile error https://github.com/Snipa22/node-cryptonote-util/pull/2 --- src/crypto/crypto.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/crypto/crypto.cpp b/src/crypto/crypto.cpp index f5f52570..df0a9e0c 100644 --- a/src/crypto/crypto.cpp +++ b/src/crypto/crypto.cpp @@ -217,11 +217,11 @@ DISABLE_VS_WARNINGS(4200) struct { ec_point a, b; } ab[]; - }; + }rcs; POP_WARNINGS static inline size_t rs_comm_size(size_t pubs_count) { - return sizeof(rs_comm) + pubs_count * sizeof(rs_comm().ab[0]); + return sizeof(rs_comm) + pubs_count * sizeof(rcs.ab[0]); } void crypto_ops::generate_ring_signature(const hash &prefix_hash, const key_image &image,