From 1ec4fd5b721cedc2e042ab3267a4eee2fc8cb0b3 Mon Sep 17 00:00:00 2001 From: Campurro Date: Fri, 9 Nov 2018 19:24:17 +0100 Subject: [PATCH] Merged mining support --- src/main.cc | 141 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 139 insertions(+), 2 deletions(-) diff --git a/src/main.cc b/src/main.cc index e11989f..5f6c8ca 100644 --- a/src/main.cc +++ b/src/main.cc @@ -17,6 +17,13 @@ using namespace node; using namespace v8; using namespace cryptonote; +const size_t TX_EXTRA_FIELD_TAG_BYTES = 1; +const size_t TX_MM_FIELD_SIZE_BYTES = 1; +const size_t MAX_VARINT_SIZE = 9; +const size_t TX_MM_TAG_MAX_BYTES = MAX_VARINT_SIZE + sizeof(crypto::hash); +const size_t MERGE_MINING_TAG_RESERVED_SIZE = TX_EXTRA_FIELD_TAG_BYTES + TX_MM_FIELD_SIZE_BYTES + TX_MM_TAG_MAX_BYTES; +const size_t POOL_NONCE_SIZE = 19; + blobdata uint64be_to_blob(uint64_t num) { blobdata res = " "; res[0] = num >> 56 & 0xff; @@ -29,7 +36,9 @@ blobdata uint64be_to_blob(uint64_t num) { res[7] = num & 0xff; return res; } - + + +/* static bool fillExtra(cryptonote::block& block1, const cryptonote::block& block2) { cryptonote::tx_extra_merge_mining_tag mm_tag; mm_tag.depth = 0; @@ -40,6 +49,55 @@ static bool fillExtra(cryptonote::block& block1, const cryptonote::block& block2 return true; } +*/ + + +static bool fillExtra(cryptonote::block& block1, const cryptonote::block& block2) +{ + if (block2.timestamp > block1.timestamp) { // get the most recent timestamp (solve duplicated timestamps on child coin) + block1.timestamp = block2.timestamp; + } + + size_t MERGE_MINING_TAG_RESERVED_SIZE_EX = MERGE_MINING_TAG_RESERVED_SIZE + POOL_NONCE_SIZE; + std::vector& extra = block1.miner_tx.extra; + std::string extraAsString(reinterpret_cast(extra.data()), extra.size()); + + std::string extraNonceTemplate; + extraNonceTemplate.push_back(TX_EXTRA_NONCE); + extraNonceTemplate.push_back(MERGE_MINING_TAG_RESERVED_SIZE_EX); + extraNonceTemplate.append(MERGE_MINING_TAG_RESERVED_SIZE, '\0'); + + size_t extraNoncePos = extraAsString.find(extraNonceTemplate); + if (std::string::npos == extraNoncePos) { + return false; + } + + cryptonote::tx_extra_merge_mining_tag tag; + tag.depth = 0; + if (!cryptonote::get_block_header_hash(block2, tag.merkle_root)) { + return false; + } + + + std::vector extraNonceReplacement; + if (!cryptonote::append_mm_tag_to_extra(extraNonceReplacement, tag)) { + return false; + } + + if (MERGE_MINING_TAG_RESERVED_SIZE < extraNonceReplacement.size()) { + return false; + } + + size_t diff = (extraNonceTemplate.size() + POOL_NONCE_SIZE) - extraNonceReplacement.size(); + if (0 < diff) { + extraNonceReplacement.push_back(TX_EXTRA_NONCE); + extraNonceReplacement.push_back(static_cast(diff - 2)); + } + + std::copy(extraNonceReplacement.begin(), extraNonceReplacement.end(), extra.begin() + extraNoncePos); + return true; +} + static bool mergeBlocks(const cryptonote::block& block1, cryptonote::block& block2, const std::vector& branch2) { block2.timestamp = block1.timestamp; @@ -70,6 +128,13 @@ static bool construct_parent_block(const cryptonote::block& b, cryptonote::block return fillExtra(parent_block, b); } + +NAN_METHOD(get_merge_mining_tag_reserved_size) { + Local returnValue = Nan::New(static_cast(MERGE_MINING_TAG_RESERVED_SIZE + POOL_NONCE_SIZE)); + info.GetReturnValue().Set(returnValue); +} + + NAN_METHOD(convert_blob) { if (info.Length() < 1) return THROW_ERROR_EXCEPTION("You must provide one argument."); @@ -90,11 +155,25 @@ NAN_METHOD(convert_blob) { b.set_blob_type(blob_type); if (!parse_and_validate_block_from_blob(input, b)) return THROW_ERROR_EXCEPTION("Failed to parse block"); + block b2 = AUTO_VAL_INIT(b2); + if (info.Length() > 2) { // MM + b2.set_blob_type(BLOB_TYPE_FORKNOTE2); // Only forknote 2 blob types support being mm as child coin + Local child_target = info[2]->ToObject(); + blobdata child_input = std::string(Buffer::Data(child_target), Buffer::Length(child_target)); + if (!Buffer::HasInstance(child_target)) return THROW_ERROR_EXCEPTION("Argument (Child block) should be a buffer object."); + if (!parse_and_validate_block_from_blob(child_input, b2)) return THROW_ERROR_EXCEPTION("Failed to parse child block"); + } + if (blob_type == BLOB_TYPE_FORKNOTE2) { block parent_block; if (!construct_parent_block(b, parent_block)) return THROW_ERROR_EXCEPTION("Failed to construct parent block"); if (!get_block_hashing_blob(parent_block, output)) return THROW_ERROR_EXCEPTION("Failed to create mining block"); } else { + if (BLOB_TYPE_CRYPTONOTE == blob_type && info.Length() > 2) { // MM + if (!fillExtra(b, b2)) { + return THROW_ERROR_EXCEPTION("Failed to add merged mining tag to parent block extra (convert_blob)"); + } + } if (!get_block_hashing_blob(b, output)) return THROW_ERROR_EXCEPTION("Failed to create mining block"); } @@ -152,13 +231,26 @@ NAN_METHOD(construct_block_blob) { b.set_blob_type(blob_type); if (!parse_and_validate_block_from_blob(block_template_blob, b)) return THROW_ERROR_EXCEPTION("Failed to parse block"); + block b2 = AUTO_VAL_INIT(b2); + if (info.Length() > 3) { // MM + b2.set_blob_type(BLOB_TYPE_FORKNOTE2); // Only forknote 2 blob types support being mm as child coin + Local child_target = info[3]->ToObject(); + blobdata child_input = std::string(Buffer::Data(child_target), Buffer::Length(child_target)); + if (!Buffer::HasInstance(child_target)) return THROW_ERROR_EXCEPTION("Argument (Child block) should be a buffer object."); + if (!parse_and_validate_block_from_blob(child_input, b2)) return THROW_ERROR_EXCEPTION("Failed to parse child block"); + } + b.nonce = nonce; if (blob_type == BLOB_TYPE_FORKNOTE2) { block parent_block; b.parent_block.nonce = nonce; if (!construct_parent_block(b, parent_block)) return THROW_ERROR_EXCEPTION("Failed to construct parent block"); if (!mergeBlocks(parent_block, b, std::vector())) return THROW_ERROR_EXCEPTION("Failed to postprocess mining block"); - } + } else if (BLOB_TYPE_CRYPTONOTE == blob_type && info.Length() > 3) { // MM + if (!fillExtra(b, b2)) { + return THROW_ERROR_EXCEPTION("Failed to add merged mining tag to parent block extra"); + } + } if (!block_to_blob(b, output)) return THROW_ERROR_EXCEPTION("Failed to convert block to blob"); @@ -227,12 +319,57 @@ NAN_METHOD(address_decode_integrated) { } } + +/** + * var mmShareBuffer = merge_blocks(shareBuffer, coins, blobtype, "monetaverde"); + */ +NAN_METHOD(merge_blocks) { + + if (info.Length() < 2) + return THROW_ERROR_EXCEPTION("You must provide two arguments (shareBuffer, block2)."); + + Local block_template_buf = info[0]->ToObject(); + Local child_block_template_buf = info[1]->ToObject(); + + if (!Buffer::HasInstance(block_template_buf)) + return THROW_ERROR_EXCEPTION("First argument should be a buffer object."); + + if (!Buffer::HasInstance(child_block_template_buf)) + return THROW_ERROR_EXCEPTION("Second argument should be a buffer object."); + + blobdata block_template_blob = std::string(Buffer::Data(block_template_buf), Buffer::Length(block_template_buf)); + blobdata child_block_template_blob = std::string(Buffer::Data(child_block_template_buf), Buffer::Length(child_block_template_buf)); + blobdata output = ""; + + block b = AUTO_VAL_INIT(b); + b.set_blob_type(BLOB_TYPE_CRYPTONOTE); + if (!parse_and_validate_block_from_blob(block_template_blob, b)) return THROW_ERROR_EXCEPTION("Failed to parse parent block (merge_blocks)"); + + block b2 = AUTO_VAL_INIT(b2); + b2.set_blob_type(BLOB_TYPE_FORKNOTE2); + if (!parse_and_validate_block_from_blob(child_block_template_blob, b2)) return THROW_ERROR_EXCEPTION("Failed to parse child block (merge_blocks)"); + + if (!mergeBlocks(b, b2, std::vector())) + return THROW_ERROR_EXCEPTION("mergeBlocks(b,b2): Failed to postprocess mining block"); + + if (!block_to_blob(b2, output)) { + return THROW_ERROR_EXCEPTION("Failed to convert block to blob (merge_blocks)"); + } + + v8::Local returnValue = Nan::CopyBuffer((char*)output.data(), output.size()).ToLocalChecked(); + info.GetReturnValue().Set(returnValue); +} + + 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("address_decode").ToLocalChecked(), Nan::GetFunction(Nan::New(address_decode)).ToLocalChecked()); Nan::Set(target, Nan::New("address_decode_integrated").ToLocalChecked(), Nan::GetFunction(Nan::New(address_decode_integrated)).ToLocalChecked()); + + Nan::Set(target, Nan::New("merge_blocks").ToLocalChecked(), Nan::GetFunction(Nan::New(merge_blocks)).ToLocalChecked()); + Nan::Set(target, Nan::New("get_merge_mining_tag_reserved_size").ToLocalChecked(), Nan::GetFunction(Nan::New(get_merge_mining_tag_reserved_size)).ToLocalChecked()); } NODE_MODULE(cryptoforknote, init)