diff --git a/package.json b/package.json index 697206d..bef4d71 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/cryptonote_core/cryptonote_basic.h b/src/cryptonote_core/cryptonote_basic.h index d59e37b..f9e6727 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() }; @@ -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 7d8562b..739b3b6 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 13bd345..cf575a1 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,38 @@ 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."); + + 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."); @@ -107,19 +136,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 +168,53 @@ 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); + v8::Local returnValue = Nan::CopyBuffer(cstr, 32).ToLocalChecked(); + info.GetReturnValue().Set( + returnValue ); } -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."); + + 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 + ); +} + +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."); @@ -178,18 +245,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 +271,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 +292,41 @@ 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(); + 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 + ); - if (!crypto::check_key(adr.m_spend_public_key) || !crypto::check_key(adr.m_view_public_key)) - NanReturnUndefined(); - - NanReturnValue(NanNew(static_cast(prefix))); + } + else + { + 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)