From d5d0965c5478c12f7738a1fe02863b49b6100384 Mon Sep 17 00:00:00 2001 From: clintar Date: Fri, 10 Apr 2015 14:06:36 -0600 Subject: [PATCH] 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 0000000..187adb2 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/nbproject/ \ No newline at end of file diff --git a/binding.gyp b/binding.gyp index 50b9802..1ecc104 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)