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", + " 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() }; @@ -479,11 +473,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); diff --git a/src/main.cc b/src/main.cc index 99e97c9a..cf575a15 100644 --- a/src/main.cc +++ b/src/main.cc @@ -12,15 +12,18 @@ #include "crypto/hash.h" #include "common/base58.h" #include "serialization/binary_utils.h" +#include + +#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; -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 +80,15 @@ 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) { - if (args.Length() < 1) - return except("You must provide one argument."); + 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 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 +96,131 @@ 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 (!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)) + 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_); +// 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 + ); } -Handle get_block_id(const Arguments& args) { - HandleScope scope; +void get_block_id(const Nan::FunctionCallbackInfo& info) { - if (args.Length() < 1) - return except("You must provide one argument."); + 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 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"); + + char *cstr = reinterpret_cast(&block_id); + v8::Local returnValue = Nan::CopyBuffer(cstr, 32).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue + ); +} + +void construct_block_blob(const Nan::FunctionCallbackInfo& info) { - Buffer* buff = Buffer::New(reinterpret_cast(&block_id), sizeof(block_id)); - return scope.Close(buff->handle_); + 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"); + b.nonce = nonce; + 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 + ); } -Handle construct_block_blob(const Arguments& args) { - HandleScope scope; +void construct_block_blob_fa(const Nan::FunctionCallbackInfo& info) { - if (args.Length() < 2) - return except("You must provide two arguments."); + 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 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 +229,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_); + v8::Local returnValue = Nan::CopyBuffer((char*)output.data(), output.size()).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue + ); } -Handle convert_blob_bb(const Arguments& args) { - HandleScope scope; +void convert_blob_bb(const Nan::FunctionCallbackInfo& info) { - if (args.Length() < 1) - return except("You must provide one argument."); + 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 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 +267,66 @@ 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_); + v8::Local returnValue = Nan::CopyBuffer((char*)output.data(), output.size()).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue + ); } -Handle address_decode(const Arguments& args) { - HandleScope scope; +void address_decode(const Nan::FunctionCallbackInfo& info) { - if (args.Length() < 1) - return except("You must provide one argument."); + 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 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()); + { + info.GetReturnValue().Set(Nan::Undefined()); + } + // info.GetReturnValue().Set(Nan::Undefined()); + account_public_address adr; - if (!::serialization::parse_binary(data, adr)) - return scope.Close(Undefined()); - - if (!crypto::check_key(adr.m_spend_public_key) || !crypto::check_key(adr.m_view_public_key)) - return scope.Close(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 + ); - return scope.Close(Integer::New(static_cast(prefix))); + } + else + { + info.GetReturnValue().Set(Nan::New(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()); +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)