RanchiMall/flocore-node
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more conversion work.

Browse Source
This commit is contained in:
Christopher Jeffrey 2014-10-02 13:13:54 -07:00
parent 40dca54613
commit 4a968d02cc
1 changed files with 70 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
src/bitcoindjs.cc
View File

@ -232,18 +232,16 @@ static void
async_import_key_after(uv_work_t *req); async_import_key_after(uv_work_t *req);
static inline void static inline void
ctx_to_jstx(const CTransaction& tx, uint256 hashBlock, Local<Object> entry); cblock_to_jsblock(const CBlock& cblock, const CBlockIndex* blockindex, Local<Object> jsblock);
static inline void static inline void
cblock_to_jsblock(const CBlock& block, const CBlockIndex* blockindex, Local<Object> obj); ctx_to_jstx(const CTransaction& ctx, uint256 hashBlock, Local<Object> jstx);
#if 0
static inline void
jsblock_to_cblock(Local<Object> jsblock, CBlock& cblock);
static inline void static inline void
jstx_to_ctx(Local<Object> jstx, CTransaction& ctx); jsblock_to_cblock(const Local<Object> jsblock, CBlock& cblock);
#endif
static inline void
jstx_to_ctx(const Local<Object> jstx, CTransaction& ctx);
static inline void static inline void
hexblock_to_cblock(std::string block_hex, CBlock& cblock); hexblock_to_cblock(std::string block_hex, CBlock& cblock);
@ -2427,31 +2425,31 @@ async_import_key_after(uv_work_t *req) {
*/ */
static inline void static inline void
cblock_to_jsblock(const CBlock& block, const CBlockIndex* blockindex, Local<Object> obj) { cblock_to_jsblock(const CBlock& cblock, const CBlockIndex* blockindex, Local<Object> jsblock) {
obj->Set(NanNew<String>("hash"), NanNew<String>(block.GetHash().GetHex().c_str())); jsblock->Set(NanNew<String>("hash"), NanNew<String>(cblock.GetHash().GetHex().c_str()));
CMerkleTx txGen(block.vtx[0]); CMerkleTx txGen(cblock.vtx[0]);
txGen.SetMerkleBranch(&block); txGen.SetMerkleBranch(&cblock);
obj->Set(NanNew<String>("confirmations"), NanNew<Number>((int)txGen.GetDepthInMainChain())); jsblock->Set(NanNew<String>("confirmations"), NanNew<Number>((int)txGen.GetDepthInMainChain()));
obj->Set(NanNew<String>("size"), NanNew<Number>((int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION))); jsblock->Set(NanNew<String>("size"), NanNew<Number>((int)::GetSerializeSize(cblock, SER_NETWORK, PROTOCOL_VERSION)));
obj->Set(NanNew<String>("height"), NanNew<Number>(blockindex->nHeight)); jsblock->Set(NanNew<String>("height"), NanNew<Number>(blockindex->nHeight));
obj->Set(NanNew<String>("version"), NanNew<Number>(block.nVersion)); jsblock->Set(NanNew<String>("version"), NanNew<Number>(cblock.nVersion));
obj->Set(NanNew<String>("merkleroot"), NanNew<String>(block.hashMerkleRoot.GetHex())); jsblock->Set(NanNew<String>("merkleroot"), NanNew<String>(cblock.hashMerkleRoot.GetHex()));
// Build merkle tree // Build merkle tree
if (block.vMerkleTree.empty()) { if (cblock.vMerkleTree.empty()) {
block.BuildMerkleTree(); cblock.BuildMerkleTree();
} }
Local<Array> merkle = NanNew<Array>(); Local<Array> merkle = NanNew<Array>();
int mi = 0; int mi = 0;
BOOST_FOREACH(uint256& hash, block.vMerkleTree) { BOOST_FOREACH(uint256& hash, cblock.vMerkleTree) {
merkle->Set(mi, NanNew<String>(hash.ToString())); merkle->Set(mi, NanNew<String>(hash.ToString()));
mi++; mi++;
} }
obj->Set(NanNew<String>("merkletree"), merkle); jsblock->Set(NanNew<String>("merkletree"), merkle);
Local<Array> txs = NanNew<Array>(); Local<Array> txs = NanNew<Array>();
int ti = 0; int ti = 0;
BOOST_FOREACH(const CTransaction& tx, block.vtx) { BOOST_FOREACH(const CTransaction& tx, cblock.vtx) {
Local<Object> entry = NanNew<Object>(); Local<Object> entry = NanNew<Object>();
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION); CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
@ -2524,7 +2522,7 @@ cblock_to_jsblock(const CBlock& block, const CBlockIndex* blockindex, Local<Obje
entry->Set(NanNew<String>("vout"), vout); entry->Set(NanNew<String>("vout"), vout);
{ {
const uint256 hashBlock = block.GetHash(); const uint256 hashBlock = cblock.GetHash();
if (hashBlock != 0) { if (hashBlock != 0) {
entry->Set(NanNew<String>("blockhash"), NanNew<String>(hashBlock.GetHex())); entry->Set(NanNew<String>("blockhash"), NanNew<String>(hashBlock.GetHex()));
map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock); map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
@ -2545,38 +2543,38 @@ cblock_to_jsblock(const CBlock& block, const CBlockIndex* blockindex, Local<Obje
txs->Set(ti, entry); txs->Set(ti, entry);
ti++; ti++;
} }
obj->Set(NanNew<String>("tx"), txs); jsblock->Set(NanNew<String>("tx"), txs);
obj->Set(NanNew<String>("time"), NanNew<Number>((boost::int64_t)block.GetBlockTime())); jsblock->Set(NanNew<String>("time"), NanNew<Number>((boost::int64_t)cblock.GetBlockTime()));
obj->Set(NanNew<String>("nonce"), NanNew<Number>((boost::uint64_t)block.nNonce)); jsblock->Set(NanNew<String>("nonce"), NanNew<Number>((boost::uint64_t)cblock.nNonce));
obj->Set(NanNew<String>("bits"), NanNew<Number>(block.nBits)); jsblock->Set(NanNew<String>("bits"), NanNew<Number>(cblock.nBits));
obj->Set(NanNew<String>("difficulty"), NanNew<Number>(GetDifficulty(blockindex))); jsblock->Set(NanNew<String>("difficulty"), NanNew<Number>(GetDifficulty(blockindex)));
obj->Set(NanNew<String>("chainwork"), NanNew<String>(blockindex->nChainWork.GetHex())); jsblock->Set(NanNew<String>("chainwork"), NanNew<String>(blockindex->nChainWork.GetHex()));
if (blockindex->pprev) { if (blockindex->pprev) {
obj->Set(NanNew<String>("previousblockhash"), NanNew<String>(blockindex->pprev->GetBlockHash().GetHex())); jsblock->Set(NanNew<String>("previousblockhash"), NanNew<String>(blockindex->pprev->GetBlockHash().GetHex()));
} }
CBlockIndex *pnext = chainActive.Next(blockindex); CBlockIndex *pnext = chainActive.Next(blockindex);
if (pnext) { if (pnext) {
obj->Set(NanNew<String>("nextblockhash"), NanNew<String>(pnext->GetBlockHash().GetHex())); jsblock->Set(NanNew<String>("nextblockhash"), NanNew<String>(pnext->GetBlockHash().GetHex()));
} }
} }
static inline void static inline void
ctx_to_jstx(const CTransaction& tx, uint256 hashBlock, Local<Object> entry) { ctx_to_jstx(const CTransaction& ctx, uint256 hashBlock, Local<Object> jstx) {
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION); CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
ssTx << tx; ssTx << ctx;
std::string strHex = HexStr(ssTx.begin(), ssTx.end()); std::string strHex = HexStr(ssTx.begin(), ssTx.end());
entry->Set(NanNew<String>("hex"), NanNew<String>(strHex)); jstx->Set(NanNew<String>("hex"), NanNew<String>(strHex));
entry->Set(NanNew<String>("txid"), NanNew<String>(tx.GetHash().GetHex())); jstx->Set(NanNew<String>("txid"), NanNew<String>(ctx.GetHash().GetHex()));
entry->Set(NanNew<String>("version"), NanNew<Number>(tx.nVersion)); jstx->Set(NanNew<String>("version"), NanNew<Number>(ctx.nVersion));
entry->Set(NanNew<String>("locktime"), NanNew<Number>(tx.nLockTime)); jstx->Set(NanNew<String>("locktime"), NanNew<Number>(ctx.nLockTime));
Local<Array> vin = NanNew<Array>(); Local<Array> vin = NanNew<Array>();
int vi = 0; int vi = 0;
BOOST_FOREACH(const CTxIn& txin, tx.vin) { BOOST_FOREACH(const CTxIn& txin, ctx.vin) {
Local<Object> in = NanNew<Object>(); Local<Object> in = NanNew<Object>();
if (tx.IsCoinBase()) { if (ctx.IsCoinBase()) {
in->Set(NanNew<String>("coinbase"), NanNew<String>(HexStr(txin.scriptSig.begin(), txin.scriptSig.end()))); in->Set(NanNew<String>("coinbase"), NanNew<String>(HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
} else { } else {
in->Set(NanNew<String>("txid"), NanNew<String>(txin.prevout.hash.GetHex())); in->Set(NanNew<String>("txid"), NanNew<String>(txin.prevout.hash.GetHex()));
@ -2590,11 +2588,11 @@ ctx_to_jstx(const CTransaction& tx, uint256 hashBlock, Local<Object> entry) {
vin->Set(vi, in); vin->Set(vi, in);
vi++; vi++;
} }
entry->Set(NanNew<String>("vin"), vin); jstx->Set(NanNew<String>("vin"), vin);
Local<Array> vout = NanNew<Array>(); Local<Array> vout = NanNew<Array>();
for (unsigned int vo = 0; vo < tx.vout.size(); vo++) { for (unsigned int vo = 0; vo < ctx.vout.size(); vo++) {
const CTxOut& txout = tx.vout[vo]; const CTxOut& txout = ctx.vout[vo];
Local<Object> out = NanNew<Object>(); Local<Object> out = NanNew<Object>();
out->Set(NanNew<String>("value"), NanNew<Number>(txout.nValue)); out->Set(NanNew<String>("value"), NanNew<Number>(txout.nValue));
out->Set(NanNew<String>("n"), NanNew<Number>((boost::int64_t)vo)); out->Set(NanNew<String>("n"), NanNew<Number>((boost::int64_t)vo));
@ -2630,20 +2628,20 @@ ctx_to_jstx(const CTransaction& tx, uint256 hashBlock, Local<Object> entry) {
vout->Set(vo, out); vout->Set(vo, out);
} }
entry->Set(NanNew<String>("vout"), vout); jstx->Set(NanNew<String>("vout"), vout);
if (hashBlock != 0) { if (hashBlock != 0) {
entry->Set(NanNew<String>("blockhash"), NanNew<String>(hashBlock.GetHex())); jstx->Set(NanNew<String>("blockhash"), NanNew<String>(hashBlock.GetHex()));
map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock); map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
if (mi != mapBlockIndex.end() && (*mi).second) { if (mi != mapBlockIndex.end() && (*mi).second) {
CBlockIndex* pindex = (*mi).second; CBlockIndex* pindex = (*mi).second;
if (chainActive.Contains(pindex)) { if (chainActive.Contains(pindex)) {
entry->Set(NanNew<String>("confirmations"), jstx->Set(NanNew<String>("confirmations"),
NanNew<Number>(1 + chainActive.Height() - pindex->nHeight)); NanNew<Number>(1 + chainActive.Height() - pindex->nHeight));
entry->Set(NanNew<String>("time"), NanNew<Number>((boost::int64_t)pindex->nTime)); jstx->Set(NanNew<String>("time"), NanNew<Number>((boost::int64_t)pindex->nTime));
entry->Set(NanNew<String>("blocktime"), NanNew<Number>((boost::int64_t)pindex->nTime)); jstx->Set(NanNew<String>("blocktime"), NanNew<Number>((boost::int64_t)pindex->nTime));
} else { } else {
entry->Set(NanNew<String>("confirmations"), NanNew<Number>(0)); jstx->Set(NanNew<String>("confirmations"), NanNew<Number>(0));
} }
} }
} }
@ -2670,31 +2668,31 @@ hextx_to_ctx(std::string tx_hex, CTransaction& ctx) {
} }
static inline void static inline void
jsblock_to_cblock(const Local<Object> obj, CBlock& block) { jsblock_to_cblock(const Local<Object> jsblock, CBlock& cblock) {
block->nVersion = (int)obj->Get(NanNew<String>("version"))->IntegerValue(); cblock->nVersion = (int)jsblock->Get(NanNew<String>("version"))->IntegerValue();
String::AsciiValue mhash__(obj->Get(NanNew<String>("merkleroot"))->ToString()); String::AsciiValue mhash__(jsblock->Get(NanNew<String>("merkleroot"))->ToString());
std::string mhash_ = *mhash__; std::string mhash_ = *mhash__;
if (mhash_[1] != 'x') mhash_ = "0x" + mhash_; if (mhash_[1] != 'x') mhash_ = "0x" + mhash_;
uint256 mhash(mhash_); uint256 mhash(mhash_);
block->hashMerkleRoot = mhash; cblock->hashMerkleRoot = mhash;
block->nTime = (unsigned int)obj->Get(NanNew<String>("time"))->IntegerValue(); cblock->nTime = (unsigned int)jsblock->Get(NanNew<String>("time"))->IntegerValue();
block->nNonce = (unsigned int)obj->Get(NanNew<String>("nonce"))->IntegerValue(); cblock->nNonce = (unsigned int)jsblock->Get(NanNew<String>("nonce"))->IntegerValue();
block->nBits = (unsigned int)obj->Get(NanNew<String>("bits"))->IntegerValue(); cblock->nBits = (unsigned int)jsblock->Get(NanNew<String>("bits"))->IntegerValue();
if (obj->Get(NanNew<String>("previousblockhash"))->IsString()) { if (jsblock->Get(NanNew<String>("previousblockhash"))->IsString()) {
String::AsciiValue hash__(obj->Get(NanNew<String>("previousblockhash"))->ToString()); String::AsciiValue hash__(jsblock->Get(NanNew<String>("previousblockhash"))->ToString());
std::string hash_ = *hash__; std::string hash_ = *hash__;
if (hash_[1] != 'x') hash_ = "0x" + hash_; if (hash_[1] != 'x') hash_ = "0x" + hash_;
uint256 hash(hash_); uint256 hash(hash_);
block->hashPrevBlock = hash; cblock->hashPrevBlock = hash;
} else { } else {
uint256 hash(std::string("0000000000000000000000000000000000000000000000000000000000000000")); uint256 hash(std::string("0000000000000000000000000000000000000000000000000000000000000000"));
block->hashPrevBlock = hash; cblock->hashPrevBlock = hash;
} }
Local<Array> txs = Local<Array>::Cast(obj->Get("tx")); Local<Array> txs = Local<Array>::Cast(jsblock->Get("tx"));
for (int ti = 0; ti < txs->Length(); ti++) { for (int ti = 0; ti < txs->Length(); ti++) {
Local<Object> entry = Local<Object>::Cast(txs->Get(ti)); Local<Object> entry = Local<Object>::Cast(txs->Get(ti));
CTransaction tx; CTransaction tx;
@ -2711,10 +2709,10 @@ jsblock_to_cblock(const Local<Object> obj, CBlock& block) {
std::string shash; std::string shash;
if (in->Get(NanNew<String>("coinbase"))->IsString()) { if (in->Get(NanNew<String>("coinbase"))->IsString()) {
String::AsciiValue shash_(obj->Get(NanNew<String>("coinbase"))->ToString()); String::AsciiValue shash_(jsblock->Get(NanNew<String>("coinbase"))->ToString());
shash = *shash_; shash = *shash_;
} else { } else {
String::AsciiValue shash_(obj->Get(NanNew<String>("scriptSig"))->ToString()); String::AsciiValue shash_(jsblock->Get(NanNew<String>("scriptSig"))->ToString());
shash = *shash_; shash = *shash_;
} }
CScript scriptSig(shash); CScript scriptSig(shash);
@ -2752,26 +2750,26 @@ jsblock_to_cblock(const Local<Object> obj, CBlock& block) {
tx.vout.push_back(txout); tx.vout.push_back(txout);
} }
block->vtx.push_back(tx); cblock->vtx.push_back(tx);
} }
} }
static inline void static inline void
jstx_to_ctx(const Local<Object> entry, CTransaction& tx, uint256 hashBlock) { jstx_to_ctx(const Local<Object> jstx, CTransaction& ctx) {
tx->nVersion = entry->Get(NanNew<String>("version"))->IntegerValue(); ctx->nVersion = jstx->Get(NanNew<String>("version"))->IntegerValue();
tx->nLockTime = entry->Get(NanNew<String>("locktime"))->IntegerValue(); ctx->nLockTime = jstx->Get(NanNew<String>("locktime"))->IntegerValue();
Local<Array> vin = Local<Array>::Cast(entry->Get("vin")); Local<Array> vin = Local<Array>::Cast(jstx->Get("vin"));
for (int vi = 0; vi < vin->Length(); vi++) { for (int vi = 0; vi < vin->Length(); vi++) {
CTxIn txin; CTxIn txin;
Local<Object> in = Local<Object>::Cast(vin->Get(vi)); Local<Object> in = Local<Object>::Cast(vin->Get(vi));
std::string shash; std::string shash;
if (in->Get(NanNew<String>("coinbase"))->IsString()) { if (in->Get(NanNew<String>("coinbase"))->IsString()) {
String::AsciiValue shash_(obj->Get(NanNew<String>("coinbase"))->ToString()); String::AsciiValue shash_(jsblock->Get(NanNew<String>("coinbase"))->ToString());
shash = *shash_; shash = *shash_;
} else { } else {
String::AsciiValue shash_(obj->Get(NanNew<String>("scriptSig"))->ToString()); String::AsciiValue shash_(jsblock->Get(NanNew<String>("scriptSig"))->ToString());
shash = *shash_; shash = *shash_;
} }
CScript scriptSig(shash); CScript scriptSig(shash);
@ -2788,10 +2786,10 @@ jstx_to_ctx(const Local<Object> entry, CTransaction& tx, uint256 hashBlock) {
txin.prevout.n = (boost::int64_t)in->Get(NanNew<String>("vout"))->IntegerValue(); txin.prevout.n = (boost::int64_t)in->Get(NanNew<String>("vout"))->IntegerValue();
txin.nSequence = (boost::int64_t)in->Get(NanNew<String>("sequence"))->IntegerValue(); txin.nSequence = (boost::int64_t)in->Get(NanNew<String>("sequence"))->IntegerValue();
tx->vin.push_bask(txin); ctx->vin.push_bask(txin);
} }
Local<Array> vout = Local<Array>::Cast(entry->Get("vout")); Local<Array> vout = Local<Array>::Cast(jstx->Get("vout"));
for (unsigned int vo = 0; vo < vout->Length(); vo++) { for (unsigned int vo = 0; vo < vout->Length(); vo++) {
CTxOut txout; CTxOut txout;
Local<Object> out = Local<Object>::Cast(vout->Get(vo)); Local<Object> out = Local<Object>::Cast(vout->Get(vo));
@ -2807,7 +2805,7 @@ jstx_to_ctx(const Local<Object> entry, CTransaction& tx, uint256 hashBlock) {
txout.scriptPubKey = scriptPubKey; txout.scriptPubKey = scriptPubKey;
tx->vout.push_back(txout); ctx->vout.push_back(txout);
} }
} }