BinaryData BinaryData::getSliceCopy(int32_t start_pos, uint32_t nChar) const
{
if(start_pos < 0)
start_pos = getSize() + start_pos;
if(start_pos + nChar > getSize())
{
cerr << "getSliceCopy: Invalid BinaryData access" << endl;
return BinaryData();
}
return BinaryData(getPtr()+start_pos, nChar);
}
// Implementing pure virtual method of ColumnBase.
inline void BinaryColumn::insert_rows(size_t row_ndx, size_t num_rows_to_insert,
size_t prior_num_rows, bool insert_nulls)
{
REALM_ASSERT_DEBUG(prior_num_rows == size());
REALM_ASSERT(row_ndx <= prior_num_rows);
REALM_ASSERT(!insert_nulls || m_nullable);
size_t row_ndx_2 = (row_ndx == prior_num_rows ? realm::npos : row_ndx);
BinaryData value = m_nullable ? BinaryData() : BinaryData("", 0);
bool add_zero_term = false;
do_insert(row_ndx_2, value, add_zero_term, num_rows_to_insert); // Throws
}
void TxIn::unserialize_checked(uint8_t const * ptr,
uint32_t size,
uint32_t nbytes,
TxRef parent,
uint32_t idx)
{
parentTx_ = parent;
index_ = idx;
uint32_t numBytes = (nbytes==0 ? BtcUtils::TxInCalcLength(ptr, size) : nbytes);
if (size < numBytes)
throw BlockDeserializingException();
dataCopy_.copyFrom(ptr, numBytes);
if (dataCopy_.getSize()-36 < 1)
throw BlockDeserializingException();
scriptOffset_ = 36 + BtcUtils::readVarIntLength(getPtr()+36);
if (dataCopy_.getSize() < 32)
throw BlockDeserializingException();
scriptType_ = BtcUtils::getTxInScriptType(getScriptRef(),
BinaryDataRef(getPtr(),32));
if(!parentTx_.isInitialized())
{
parentHeight_ = UINT32_MAX;
parentHash_ = BinaryData(0);
}
}
inline BinaryData BinaryColumn::get(size_t ndx) const noexcept
{
REALM_ASSERT_DEBUG(ndx < size());
if (root_is_leaf()) {
bool is_big = m_array->get_context_flag();
BinaryData ret;
if (!is_big) {
// Small blobs root leaf
ArrayBinary* leaf = static_cast<ArrayBinary*>(m_array.get());
ret = leaf->get(ndx);
}
else {
// Big blobs root leaf
ArrayBigBlobs* leaf = static_cast<ArrayBigBlobs*>(m_array.get());
ret = leaf->get(ndx);
}
if (!m_nullable && ret.is_null())
return BinaryData("", 0); // return empty string (non-null)
return ret;
}
// Non-leaf root
std::pair<MemRef, size_t> p = m_array->get_bptree_leaf(ndx);
const char* leaf_header = p.first.m_addr;
size_t ndx_in_leaf = p.second;
Allocator& alloc = m_array->get_alloc();
bool is_big = Array::get_context_flag_from_header(leaf_header);
if (!is_big) {
// Small blobs
return ArrayBinary::get(leaf_header, ndx_in_leaf, alloc);
}
// Big blobs
return ArrayBigBlobs::get(leaf_header, ndx_in_leaf, alloc);
}
void TxOut::unserialize_checked( uint8_t const * ptr,
uint32_t size,
uint32_t nbytes,
TxRef parent,
uint32_t idx)
{
parentTx_ = parent;
index_ = idx;
uint32_t numBytes = (nbytes==0 ? BtcUtils::TxOutCalcLength(ptr) : nbytes);
if (size < numBytes)
throw BlockDeserializingException();
dataCopy_.copyFrom(ptr, numBytes);
scriptOffset_ = 8 + BtcUtils::readVarIntLength(getPtr()+8);
if (dataCopy_.getSize()-scriptOffset_-getScriptSize() > size)
throw BlockDeserializingException();
BinaryDataRef scriptRef(dataCopy_.getPtr()+scriptOffset_, getScriptSize());
scriptType_ = BtcUtils::getTxOutScriptType(scriptRef);
uniqueScrAddr_ = BtcUtils::getTxOutScrAddr(scriptRef);
if(!parentTx_.isInitialized())
{
parentHeight_ = UINT32_MAX;
parentHash_ = BinaryData(0);
}
}
void MzMLSpectrumDecoder::handleBinaryDataArray(xercesc::DOMNode* indexListNode, std::vector<BinaryData>& data_)
{
// access result through data_.back()
data_.push_back(BinaryData());
XMLCh* TAG_CV = xercesc::XMLString::transcode("cvParam");
XMLCh* TAG_binary = xercesc::XMLString::transcode("binary");
XMLCh* TAG_userParam = xercesc::XMLString::transcode("userParam");
XMLCh* TAG_referenceableParamGroupRef = xercesc::XMLString::transcode("referenceableParamGroupRef");
// Iterate through binaryDataArray elements
// only allowed subelements:
// - referenceableParamGroupRef (0+)
// - cvParam (0+)
// - userParam (0+)
// - binary (1)
xercesc::DOMNodeList* index_elems = indexListNode->getChildNodes();
const XMLSize_t nodeCount_ = index_elems->getLength();
for (XMLSize_t j = 0; j < nodeCount_; ++j)
{
xercesc::DOMNode* currentNode = index_elems->item(j);
if (currentNode->getNodeType() && // true is not NULL
currentNode->getNodeType() == xercesc::DOMNode::ELEMENT_NODE) // is element
{
xercesc::DOMElement* currentElement = dynamic_cast<xercesc::DOMElement*>(currentNode);
if (xercesc::XMLString::equals(currentElement->getTagName(), TAG_binary))
{
// TODO do not use expensive xercesc transcoding!
data_.back().base64 = xercesc::XMLString::transcode(currentNode->getTextContent());
}
else if (xercesc::XMLString::equals(currentElement->getTagName(), TAG_CV))
{
std::string accession = xercesc::XMLString::transcode(currentElement->getAttribute(xercesc::XMLString::transcode("accession")));
std::string value = xercesc::XMLString::transcode(currentElement->getAttribute(xercesc::XMLString::transcode("value")));
std::string name = xercesc::XMLString::transcode(currentElement->getAttribute(xercesc::XMLString::transcode("name")));
//handleCVParam(data_, accession, value, name);
Internal::MzMLHandlerHelper::handleBinaryDataArrayCVParam(data_, accession, value, name);
}
else if (xercesc::XMLString::equals(currentElement->getTagName(), TAG_userParam))
{
std::cout << " unhandled userParam" << std::endl;
}
else if (xercesc::XMLString::equals(currentElement->getTagName(), TAG_referenceableParamGroupRef))
{
std::cout << " unhandled referenceableParamGroupRef" << std::endl;
}
else
{
//std::cout << "unhandled" << (string)xercesc::XMLString::transcode(currentNode->getNodeName() << std::endl;
}
}
}
xercesc::XMLString::release(&TAG_CV);
xercesc::XMLString::release(&TAG_binary);
xercesc::XMLString::release(&TAG_userParam);
xercesc::XMLString::release(&TAG_referenceableParamGroupRef);
}
UnspentTxOut::UnspentTxOut(void) :
txHash_(BtcUtils::EmptyHash()),
txOutIndex_(0),
txHeight_(0),
value_(0),
script_(BinaryData(0)),
isMultisigRef_(false)
{
// Nothing to do here
}
BinaryData BinaryData::GetDataRef(size_t offset, size_t inSize)
{
if (inSize > Size())
inSize = Size();
if (offset > Size())
offset = Size();
if (offset + inSize > Size())
inSize = Size() - offset;
return BinaryData(*this + offset, inSize, false);
}
void WalletGroup::updateLedgerFilter(const vector<BinaryData>& walletsList)
{
ReadWriteLock::ReadLock rl(lock_);
for (auto& wlt : values(wallets_))
wlt->uiFilter_ = false;
for (auto walletID : walletsList)
wallets_[walletID]->uiFilter_ = true;
bdvPtr_->flagRefresh(BDV_filterChanged, BinaryData());
}
void tbl_nativeDoByteArray(M doBinary, T* pTable, JNIEnv* env, jlong columnIndex, jlong rowIndex, jbyteArray dataArray)
{
jbyte* bytePtr = env->GetByteArrayElements(dataArray, NULL);
if (!bytePtr) {
ThrowException(env, IllegalArgument, "doByteArray");
return;
}
size_t dataLen = S(env->GetArrayLength(dataArray));
(pTable->*doBinary)( S(columnIndex), S(rowIndex), BinaryData(reinterpret_cast<char*>(bytePtr), dataLen));
env->ReleaseByteArrayElements(dataArray, bytePtr, 0);
}
HashString TxIOPair::getTxHashOfInput(const LMDBBlockDatabase *db) const
{
if (!hasTxIn())
return BtcUtils::EmptyHash();
else if (txHashOfInput_.getSize() == 32)
return txHashOfInput_;
else if (txRefOfInput_.isInitialized() && db != nullptr)
{
txHashOfInput_ = txRefOfInput_.attached(db).getThisHash();
return txHashOfInput_;
}
return BinaryData(0);
}
BinaryData BtcUtils::getGroestlHash(uint8_t const * strToHash, uint32_t nBytes) {
sph_groestl512_context ctx_gr[2];
static unsigned char pblank[1];
uint8_t hash1[64];
sph_groestl512_init(&ctx_gr[0]);
sph_groestl512 (&ctx_gr[0], strToHash ? strToHash : pblank, nBytes);
sph_groestl512_close(&ctx_gr[0], hash1);
uint8_t hash2[64];
sph_groestl512_init(&ctx_gr[1]);
sph_groestl512(&ctx_gr[1], hash1, 64);
sph_groestl512_close(&ctx_gr[1], hash2);
return BinaryData(hash2, 32);
}
void BlockHeader::unserialize(uint8_t const * ptr, uint32_t size)
{
if (size < HEADER_SIZE)
throw BlockDeserializingException();
dataCopy_.copyFrom(ptr, HEADER_SIZE);
BtcUtils::getHash256(dataCopy_.getPtr(), HEADER_SIZE, thisHash_);
difficultyDbl_ = BtcUtils::convertDiffBitsToDouble(
BinaryDataRef(dataCopy_.getPtr()+72, 4));
isInitialized_ = true;
nextHash_ = BinaryData(0);
blockHeight_ = UINT32_MAX;
difficultySum_ = -1;
isMainBranch_ = false;
isOrphan_ = true;
numTx_ = UINT32_MAX;
}
void BlockHeaderRef::unserialize(uint8_t const * ptr)
{
self_.setRef(ptr, HEADER_SIZE);
BtcUtils::getHash256(self_.getPtr(), HEADER_SIZE, thisHash_);
difficultyDbl_ = BtcUtils::convertDiffBitsToDouble(
BinaryDataRef(self_.getPtr()+72, 4));
isInitialized_ = true;
nextHash_ = BinaryData(0);
blockHeight_ = UINT32_MAX;
blockNumBytes_ = 0;
blkByteLoc_ = 0;
difficultySum_ = -1;
isMainBranch_ = false;
isOrphan_ = true;
isFinishedCalc_ = false;
isOnDiskYet_ = false;
txPtrList_ = vector<TxRef*>(0);
}
void BlockDataViewer::flagRefresh(BDV_refresh refresh, const BinaryData& refreshID)
{
if (saf_->bdmIsRunning() == false)
return;
unique_lock<mutex> lock(refreshLock_);
if (refresh_ != BDV_refreshAndRescan)
{
if (refresh == BDV_refreshAndRescan)
refresh_ = BDV_refreshAndRescan;
else
refresh_ = BDV_refreshSkipRescan;
}
if (refreshID.getSize())
refreshIDSet_.insert(refreshID);
if (refresh == BDV_filterChanged)
refreshIDSet_.insert(BinaryData("wallet_filter_changed"));
notifyMainThread();
}
inline BinaryData TrivialReplication::get_uncommitted_changes() const noexcept
{
const char* data = m_transact_log_buffer.data();
size_t size = write_position() - data;
return BinaryData(data, size);
}
AbstractShader::BinaryData DXShader::GetBinary() const
{
return BinaryData(m_bytecode->Data(), m_bytecode->Data() + m_bytecode->Size());
}
void tbl_nativeDoMixed(M doMixed, T* pTable, JNIEnv* env, jlong columnIndex, jlong rowIndex, jobject jMixedValue)
{
DataType valueType = GetMixedObjectType(env, jMixedValue);
switch(valueType) {
case type_Int:
{
jlong longValue = GetMixedIntValue(env, jMixedValue);
(pTable->*doMixed)( S(columnIndex), S(rowIndex), Mixed(static_cast<int64_t>(longValue)));
return;
}
case type_Float:
{
jfloat floatValue = GetMixedFloatValue(env, jMixedValue);
(pTable->*doMixed)( S(columnIndex), S(rowIndex), Mixed(floatValue));
return;
}
case type_Double:
{
jdouble doubleValue = GetMixedDoubleValue(env, jMixedValue);
(pTable->*doMixed)( S(columnIndex), S(rowIndex), Mixed(doubleValue));
return;
}
case type_Bool:
{
jboolean boolValue = GetMixedBooleanValue(env, jMixedValue);
(pTable->*doMixed)( S(columnIndex), S(rowIndex), Mixed(boolValue != 0 ? true : false));
return;
}
case type_String:
{
jstring stringValue = GetMixedStringValue(env, jMixedValue);
JStringAccessor string(env, stringValue); // throws
(pTable->*doMixed)( S(columnIndex), S(rowIndex), StringData(string));
return;
}
case type_DateTime:
{
jlong dateTimeValue = GetMixedDateTimeValue(env, jMixedValue);
DateTime date(dateTimeValue);
(pTable->*doMixed)( S(columnIndex), S(rowIndex), Mixed(date));
return;
}
case type_Binary:
{
jint mixedBinaryType = GetMixedBinaryType(env, jMixedValue);
if (mixedBinaryType == 0) {
jbyteArray dataArray = GetMixedByteArrayValue(env, jMixedValue);
if (!dataArray)
break;
char* data = reinterpret_cast<char*>(env->GetByteArrayElements(dataArray, NULL));
if (!data)
break;
size_t size = S(env->GetArrayLength(dataArray));
(pTable->*doMixed)( S(columnIndex), S(rowIndex), BinaryData(data, size));
env->ReleaseByteArrayElements(dataArray, reinterpret_cast<jbyte*>(data), 0);
return;
}
else if (mixedBinaryType == 1) {
jobject jByteBuffer = GetMixedByteBufferValue(env, jMixedValue);
if (!jByteBuffer)
break;
BinaryData binaryData;
if (GetBinaryData(env, jByteBuffer, binaryData))
(pTable->*doMixed)( S(columnIndex), S(rowIndex), binaryData);
return;
}
break; // failed
}
case type_Table:
{
(pTable->*doMixed)( S(columnIndex), S(rowIndex), Mixed::subtable_tag());
return;
}
case type_Mixed:
break;
case type_Link:
break;
case type_LinkList:
break;
}
TR_ERR("ERROR: nativeSetMixed() failed.")
ThrowException(env, IllegalArgument, "nativeSetMixed()");
}
void BlockchainScanner::scanBlockData(shared_ptr<BlockDataBatch> batch)
{
//getBlock lambda
auto getBlock = [&](unsigned height)->BlockData
{
auto iter = batch->blocks_.find(height);
if (iter == batch->blocks_.end())
{
//TODO: encapsulate in try block to catch deser errors and signal pull thread
//termination before exiting scope. cant have the scan thread hanging if this
//one fails. Also update batch->end_ if we didn't go as far as that block height
//grab block file map
BlockHeader* blockheader = nullptr;
blockheader = &blockchain_->getHeaderByHeight(height);
auto filenum = blockheader->getBlockFileNum();
auto mapIter = batch->fileMaps_.find(filenum);
if (mapIter == batch->fileMaps_.end())
{
//we haven't grabbed that file map yet
auto insertPair = batch->fileMaps_.insert(
make_pair(filenum, move(blockDataLoader_.get(filenum, true))));
mapIter = insertPair.first;
}
auto filemap = mapIter->second.get();
//find block and deserialize it
try
{
BlockData bdata;
bdata.deserialize(
filemap->getPtr() + blockheader->getOffset(),
blockheader->getBlockSize(),
blockheader, false);
auto insertPair = batch->blocks_.insert(make_pair(height, move(bdata)));
iter = insertPair.first;
}
catch (...)
{
LOGERR << "unknown block deser error during scan at height #" << height;
batch->exceptionPtr_ = current_exception();
return BlockData();
}
}
return iter->second;
};
//parser lambda
auto blockDataLoop = [&](function<void(const BlockData&)> callback)
{
auto currentBlock = batch->start_;
while (currentBlock <= batch->end_)
{
BlockData&& bdata = getBlock(currentBlock);
if (!bdata.isInitialized())
return;
callback(bdata);
currentBlock += totalThreadCount_;
}
};
//txout lambda
auto txoutParser = [&](const BlockData& blockdata)->void
{
//TODO: flag isMultisig
const BlockHeader* header = blockdata.header();
//update processed height
auto topHeight = header->getBlockHeight();
batch->highestProcessedHeight_ = topHeight;
auto& txns = blockdata.getTxns();
for (unsigned i = 0; i < txns.size(); i++)
{
const BCTX& txn = *(txns[i].get());
for (unsigned y = 0; y < txn.txouts_.size(); y++)
{
auto& txout = txn.txouts_[y];
BinaryRefReader brr(
txn.data_ + txout.first, txout.second);
brr.advance(8);
unsigned scriptSize = (unsigned)brr.get_var_int();
auto&& scrAddr = BtcUtils::getTxOutScrAddr(
brr.get_BinaryDataRef(scriptSize));
if (!scrAddrFilter_->hasScrAddress(scrAddr))
continue;
//if we got this far, this txout is ours
//get tx hash
auto& txHash = txn.getHash();
//construct StoredTxOut
StoredTxOut stxo;
stxo.dataCopy_ = BinaryData(
txn.data_ + txout.first, txout.second);
stxo.parentHash_ = txHash;
stxo.blockHeight_ = header->getBlockHeight();
stxo.duplicateID_ = header->getDuplicateID();
stxo.txIndex_ = i;
stxo.txOutIndex_ = y;
stxo.scrAddr_ = scrAddr;
stxo.spentness_ = TXOUT_UNSPENT;
stxo.parentTxOutCount_ = txn.txouts_.size();
stxo.isCoinbase_ = txn.isCoinbase_;
auto value = stxo.getValue();
auto&& hgtx = DBUtils::heightAndDupToHgtx(
stxo.blockHeight_, stxo.duplicateID_);
auto&& txioKey = DBUtils::getBlkDataKeyNoPrefix(
stxo.blockHeight_, stxo.duplicateID_,
i, y);
//update utxos_
auto& stxoHashMap = batch->utxos_[txHash];
stxoHashMap.insert(make_pair(y, move(stxo)));
//update ssh_
auto& ssh = batch->ssh_[scrAddr];
auto& subssh = ssh.subHistMap_[hgtx];
//deal with txio count in subssh at serialization
TxIOPair txio;
txio.setValue(value);
txio.setTxOut(txioKey);
txio.setFromCoinbase(txn.isCoinbase_);
subssh.txioMap_.insert(make_pair(txioKey, move(txio)));
}
}
};
//txin lambda
auto txinParser = [&](const BlockData& blockdata)->void
{
const BlockHeader* header = blockdata.header();
auto& txns = blockdata.getTxns();
for (unsigned i = 0; i < txns.size(); i++)
{
const BCTX& txn = *(txns[i].get());
for (unsigned y = 0; y < txn.txins_.size(); y++)
{
auto& txin = txn.txins_[y];
BinaryDataRef outHash(
txn.data_ + txin.first, 32);
auto utxoIter = utxoMap_.find(outHash);
if (utxoIter == utxoMap_.end())
continue;
unsigned txOutId = READ_UINT32_LE(
txn.data_ + txin.first + 32);
auto idIter = utxoIter->second.find(txOutId);
if (idIter == utxoIter->second.end())
continue;
//if we got this far, this txins consumes one of our utxos
//create spent txout
auto&& hgtx = DBUtils::getBlkDataKeyNoPrefix(
header->getBlockHeight(), header->getDuplicateID());
auto&& txinkey = DBUtils::getBlkDataKeyNoPrefix(
header->getBlockHeight(), header->getDuplicateID(),
i, y);
StoredTxOut stxo = idIter->second;
stxo.spentness_ = TXOUT_SPENT;
stxo.spentByTxInKey_ = txinkey;
//if this tx's hash was never pulled, let's add it to the stxo's
//parent hash, in order to keep track of this tx in the hint db
if (txn.txHash_.getSize() == 0)
stxo.parentHash_ = move(txn.getHash());
//add to ssh_
auto& ssh = batch->ssh_[stxo.getScrAddress()];
auto& subssh = ssh.subHistMap_[hgtx];
//deal with txio count in subssh at serialization
TxIOPair txio;
auto&& txoutkey = stxo.getDBKey(false);
txio.setTxOut(txoutkey);
txio.setTxIn(txinkey);
txio.setValue(stxo.getValue());
subssh.txioMap_[txoutkey] = move(txio);
//add to spentTxOuts_
batch->spentTxOuts_.push_back(move(stxo));
}
}
};
//txout loop
blockDataLoop(txoutParser);
//done with txouts, fill the future flag and wait on the mutex
//to move to txins processing
batch->flagUtxoScanDone();
unique_lock<mutex> txinLock(batch->parseTxinMutex_);
//txins loop
blockDataLoop(txinParser);
}
void StackResolver::processOpCode(const OpCode& oc)
{
if (oc.opcode_ >= 1 && oc.opcode_ <= 75)
{
pushdata(oc.dataRef_);
return;
}
if (oc.opcode_ >= 81 && oc.opcode_ <= 96)
{
unsigned val = oc.opcode_ - 80;
push_int(val);
return;
}
opCodeCount_++;
switch (oc.opcode_)
{
case OP_0:
pushdata(BinaryData());
break;
case OP_PUSHDATA1:
case OP_PUSHDATA2:
case OP_PUSHDATA4:
pushdata(oc.dataRef_);
break;
case OP_DUP:
op_dup();
break;
case OP_HASH160:
case OP_SHA256:
{
opHash_ = true;
op_1item_verify(oc);
break;
}
case OP_RIPEMD160:
case OP_HASH256:
op_1item_verify(oc);
break;
case OP_EQUAL:
{
if (opCodeCount_ == 2 && opHash_)
isP2SH_ = true;
op_2items(oc);
break;
}
case OP_CHECKSIG:
op_2items(oc);
break;
case OP_EQUALVERIFY:
case OP_CHECKSIGVERIFY:
op_2items_verify(oc);
break;
case OP_CHECKMULTISIG:
case OP_CHECKMULTISIGVERIFY:
push_op_code(oc);
break;
default:
throw ScriptException("opcode not implemented with reverse stack");
}
}
bool ScrAddrFilter::registerAddressBatch(
const map<shared_ptr<BtcWallet>, vector<BinaryData>>& wltNAddrMap,
bool areNew)
{
/***
Gets a scrAddr ready for loading. Returns false if the BDM is initialized,
in which case wltPtr will be called back with the address once it is ready
doScan:
1: don't scan, new addresses
0: scan while taking count of the existing history
-1: wipe existing history then scan
***/
//check if the BDM is initialized. There ought to be a better way than
//checking the top block
if (bdmIsRunning())
{
//BDM is initialized and maintenance thread is running, check mode
if (armoryDbType_ == ARMORY_DB_SUPER)
{
//supernode: nothing to do, signal the wallet that its scrAddr bulk
//is ready by passing isNew as true. Pass a blank BinaryData for the
//top scanned block hash in this case, it will be ignored anyways
while (mergeLock_.fetch_or(1, memory_order_acquire));
for (auto& batch : wltNAddrMap)
{
for (auto& sa : batch.second)
scrAddrDataForSideScan_.scrAddrsToMerge_.insert({ sa, 0 });
mergeFlag_ = true;
}
mergeLock_.store(0, memory_order_release);
for (auto& batch : wltNAddrMap)
{
batch.first->prepareScrAddrForMerge(
batch.second, true, BinaryData());
batch.first->needsRefresh();
}
return false;
}
//check DB for the scrAddr's SSH
StoredScriptHistory ssh;
ScrAddrFilter* topChild = this;
while (topChild->child_)
topChild = topChild->child_.get();
topChild->child_ = shared_ptr<ScrAddrFilter>(copy());
ScrAddrFilter* sca = topChild->child_.get();
sca->setRoot(this);
if (!areNew)
{
//mark existing history for wipe and rescan from block 0
sca->doScan_ = true;
for (auto& batch : wltNAddrMap)
{
for (const auto& scrAddr : batch.second)
sca->regScrAddrForScan(scrAddr, 0);
}
}
else
{
//mark addresses as fresh to skip DB scan
sca->doScan_ = false;
for (auto& batch : wltNAddrMap)
{
for (const auto& scrAddr : batch.second)
sca->regScrAddrForScan(scrAddr, 0);
}
}
sca->buildSideScanData(wltNAddrMap);
flagForScanThread();
return false;
}
else
{
//BDM isnt initialized yet, the maintenance thread isnt running,
//just register the scrAddr and return true.
for (auto& batch : wltNAddrMap)
{
for (const auto& scrAddr : batch.second)
scrAddrMap_.insert(make_pair(scrAddr, 0));
}
return true;
}
}
BinaryData SigHashDataLegacy::getDataForSigHashAll(const TransactionStub& stub,
BinaryDataRef subScript, unsigned inputIndex)
{
//grab subscript
auto lastCSoffset = stub.getLastCodeSeparatorOffset(inputIndex);
auto subScriptLen = subScript.getSize() - lastCSoffset;
auto&& presubscript = subScript.getSliceRef(lastCSoffset, subScriptLen);
//tokenize op_cs chunks
auto&& tokens = tokenize(presubscript, OP_CODESEPARATOR);
BinaryData subscript;
if (tokens.size() == 1)
{
subscript = move(presubscript);
}
else
{
for (auto& token : tokens)
{
subscript.append(token);
}
}
//isolate outputs
auto&& serializedOutputs = stub.getSerializedOutputScripts();
//isolate inputs
auto&& txinsData = stub.getTxInsData();
auto txin_count = txinsData.size();
BinaryWriter strippedTxins;
for (unsigned i=0; i < txin_count; i++)
{
strippedTxins.put_BinaryData(txinsData[i].outputHash_);
strippedTxins.put_uint32_t(txinsData[i].outputIndex_);
if (inputIndex != i)
{
//put empty varint
strippedTxins.put_var_int(0);
//and sequence
strippedTxins.put_uint32_t(txinsData[i].sequence_);
}
else
{
//scriptsig
strippedTxins.put_var_int(subscript.getSize());
strippedTxins.put_BinaryData(subscript);
//sequence
strippedTxins.put_uint32_t(txinsData[i].sequence_);
}
}
//wrap it up
BinaryWriter scriptSigData;
//version
scriptSigData.put_uint32_t(stub.getVersion());
//txin count
scriptSigData.put_var_int(txin_count);
//txins
scriptSigData.put_BinaryData(strippedTxins.getData());
//txout count
scriptSigData.put_var_int(stub.getTxOutCount());
//txouts
scriptSigData.put_BinaryData(serializedOutputs);
//locktime
scriptSigData.put_uint32_t(stub.getLockTime());
//sighashall
scriptSigData.put_uint32_t(1);
return BinaryData(scriptSigData.getData());
}
BinaryData TxOut::getScript(void)
{
return BinaryData( dataCopy_.getPtr()+scriptOffset_, getScriptSize() );
}
BinaryData TxOutRef::getScript(void)
{
return BinaryData( self_.getPtr()+scriptOffset_, getScriptSize() );
}
BinaryData TxIn::getScript(void) const
{
uint32_t scrLen = (uint32_t)BtcUtils::readVarInt(getPtr()+36);
return BinaryData(getPtr() + getScriptOffset(), scrLen);
}
