void OutPoint::unserialize(BinaryRefReader & brr)
{
if (brr.getSizeRemaining() < 32)
throw BlockDeserializingException();
brr.get_BinaryData(txHash_, 32);
txOutIndex_ = brr.get_uint32_t();
}
IntType IntType::deserialize(BinaryRefReader& brr)
{
auto type_code = brr.get_uint8_t();
if (type_code != INTTYPE_CODE)
BtcUtils::throw_type_error(INTTYPE_CODE, type_code);
return IntType(brr.get_var_int());
}
void TxOut::unserialize( BinaryRefReader & brr,
uint32_t nbytes,
TxRef parent,
uint32_t idx)
{
unserialize_checked( brr.getCurrPtr(), brr.getSizeRemaining(), nbytes, parent, idx );
brr.advance(getSize());
}
void BitcoinNetAddr::deserialize(BinaryRefReader brr)
{
if (brr.getSize() != NETADDR_NOTIME)
throw BitcoinMessageDeserError("invalid netaddr size");
services_ = brr.get_uint64_t();
auto ipv6bdr = brr.get_BinaryDataRef(16);
memcpy(&ipV6_, ipv6bdr.getPtr(), 16);
port_ = brr.get_uint16_t();
}
size_t ScriptParser::seekToOpCode(BinaryRefReader& brr, OPCODETYPE opcode) const
{
while (brr.getSizeRemaining() > 0)
{
auto&& oc = getNextOpcode(brr);
if (oc.opcode_ == opcode)
return brr.getPosition() - 1 - oc.dataRef_.getSize();
}
return brr.getPosition();
}
BinaryDataObject BinaryDataObject::deserialize(BinaryRefReader& brr)
{
auto type_code = brr.get_uint8_t();
if (type_code != BINARYDATAOBJECT_CODE)
BtcUtils::throw_type_error(BINARYDATAOBJECT_CODE, type_code);
auto size = brr.get_var_int();
if (size > brr.getSizeRemaining())
throw runtime_error("invalid bdo size");
return BinaryDataObject(brr.get_BinaryDataRef(size));
}
ErrorType ErrorType::deserialize(BinaryRefReader& brr)
{
auto type_code = brr.get_uint8_t();
if (type_code != ERRTYPE_CODE)
BtcUtils::throw_type_error(ERRTYPE_CODE, type_code);
auto size = brr.get_var_int();
if (size > brr.getSizeRemaining())
throw runtime_error("invalid data len");
return ErrorType(string((char*)brr.getCurrPtr(), size));
}
bool DBUtils::checkPrefixByte(BinaryRefReader & brr,
DB_PREFIX prefix,
bool rewindWhenDone)
{
uint8_t oneByte = brr.get_uint8_t();
bool out = (oneByte == (uint8_t)prefix);
if (rewindWhenDone)
brr.rewind(1);
return out;
}
BLKDATA_TYPE DBUtils::readBlkDataKeyNoPrefix(
BinaryRefReader & brr,
uint32_t & height,
uint8_t & dupID,
uint16_t & txIdx,
uint16_t & txOutIdx)
{
BinaryData hgtx = brr.get_BinaryData(4);
height = hgtxToHeight(hgtx);
dupID = hgtxToDupID(hgtx);
if (brr.getSizeRemaining() == 0)
{
txIdx = 0xffff;
txOutIdx = 0xffff;
return BLKDATA_HEADER;
}
else if (brr.getSizeRemaining() == 2)
{
txIdx = brr.get_uint16_t(BE);
txOutIdx = 0xffff;
return BLKDATA_TX;
}
else if (brr.getSizeRemaining() == 4)
{
txIdx = brr.get_uint16_t(BE);
txOutIdx = brr.get_uint16_t(BE);
return BLKDATA_TXOUT;
}
else
{
LOGERR << "Unexpected bytes remaining: " << brr.getSizeRemaining();
return NOT_BLKDATA;
}
}
ProgressData ProgressData::deserialize(BinaryRefReader& brr)
{
auto type_code = brr.get_uint8_t();
if (type_code != PROGRESSDATA_CODE)
BtcUtils::throw_type_error(PROGRESSDATA_CODE, type_code);
ProgressData pd;
pd.phase_ = (BDMPhase)brr.get_uint8_t();
pd.progress_ = brr.get_double();
pd.time_ = brr.get_uint32_t();
pd.numericProgress_ = brr.get_uint32_t();
return pd;
}
void ScriptParser::parseScript(BinaryRefReader& brr)
{
while (brr.getSizeRemaining() != 0)
{
auto&& oc = getNextOpcode(brr);
processOpCode(oc);
}
}
BinaryDataVector BinaryDataVector::deserialize(BinaryRefReader& brr)
{
auto type_code = brr.get_uint8_t();
if (type_code != BINARYDATAVECTOR_CODE)
BtcUtils::throw_type_error(BINARYDATAVECTOR_CODE, type_code);
auto size = brr.get_var_int();
if (size > brr.getSizeRemaining())
throw runtime_error("invalid bdvec size");
BinaryDataVector bdvec;
auto count = brr.get_var_int();
for (unsigned i = 0; i < count; i++)
{
auto bdsize = brr.get_var_int();
if (bdsize > brr.getSizeRemaining())
throw runtime_error("invalid bd size");
auto&& bdo = brr.get_BinaryData(bdsize);
bdvec.push_back(move(bdo));
}
return bdvec;
}
bool DBUtils::checkPrefixByteWError(BinaryRefReader & brr,
DB_PREFIX prefix,
bool rewindWhenDone)
{
uint8_t oneByte = brr.get_uint8_t();
bool out;
if (oneByte == (uint8_t)prefix)
out = true;
else
{
LOGERR << "Unexpected prefix byte: "
<< "Expected: " << getPrefixName(prefix)
<< "Received: " << getPrefixName(oneByte);
out = false;
}
if (rewindWhenDone)
brr.rewind(1);
return out;
}
void StackInterpreter::processScript(BinaryRefReader& brr, bool isOutputScript)
{
if (txStubPtr_ == nullptr)
throw ("uninitialized stack");
if (isOutputScript)
outputScriptRef_ = brr.getRawRef();
opcount_ = 0;
isValid_ = false;
ScriptParser::parseScript(brr);
}
BLKDATA_TYPE DBUtils::readBlkDataKey(BinaryRefReader & brr,
uint32_t & height,
uint8_t & dupID,
uint16_t & txIdx,
uint16_t & txOutIdx)
{
uint8_t prefix = brr.get_uint8_t();
if (prefix != (uint8_t)DB_PREFIX_TXDATA)
{
height = 0xffffffff;
dupID = 0xff;
txIdx = 0xffff;
txOutIdx = 0xffff;
return NOT_BLKDATA;
}
return readBlkDataKeyNoPrefix(brr, height, dupID, txIdx, txOutIdx);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//// ScriptParser
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
OpCode ScriptParser::getNextOpcode(BinaryRefReader& brr) const
{
OpCode val;
val.offset_ = brr.getPosition();
val.opcode_ = brr.get_uint8_t();
if (val.opcode_ <= 75 && val.opcode_ > 0)
{
val.dataRef_ = brr.get_BinaryDataRef(val.opcode_);
}
else
{
unsigned len = 0;
switch (val.opcode_)
{
case OP_PUSHDATA1:
len = brr.get_uint8_t();
break;
case OP_PUSHDATA2:
len = brr.get_uint16_t();
break;
case OP_PUSHDATA4:
len = brr.get_uint32_t();
break;
case OP_IF:
case OP_NOTIF:
len = brr.getSizeRemaining();
break;
default:
return val;
}
val.dataRef_ = brr.get_BinaryDataRef(len);
}
return val;
}
void TxOutRef::unserialize(BinaryRefReader & brr, uint32_t nbytes, TxRef* parent, int32_t idx)
{
unserialize( brr.getCurrPtr(), nbytes, parent, idx );
brr.advance(nBytes_);
}
LedgerEntryVector LedgerEntryVector::deserialize(BinaryRefReader& brr)
{
LedgerEntryVector lev;
auto type_code = brr.get_uint8_t();
if (type_code != LEDGERENTRYVECTOR_CODE)
BtcUtils::throw_type_error(LEDGERENTRYVECTOR_CODE, type_code);
auto count = brr.get_var_int();
for (unsigned i = 0; i < count; i++)
{
auto leSize = brr.get_var_int();
if (leSize > brr.getSizeRemaining())
throw runtime_error("deser size mismatch");
auto idSize = brr.get_var_int();
if (idSize + 53 != leSize)
throw runtime_error("deser size mismatch");
string leid((char*)brr.getCurrPtr(), idSize);
brr.advance(idSize);
auto value = (int64_t*)brr.getCurrPtr();
brr.advance(8);
auto blockNum = brr.get_uint32_t();
auto txHash = brr.get_BinaryDataRef(32);
auto txindex = brr.get_uint32_t();
auto txTime = brr.get_uint32_t();
BitUnpacker<uint8_t> bit(brr.get_uint8_t());
auto coinbase = bit.getBit();
auto sts = bit.getBit();
auto change = bit.getBit();
auto rbf = bit.getBit();
LedgerEntryData led(leid, *value,
blockNum, txHash, txindex, txTime,
coinbase, sts, change, rbf);
lev.push_back(move(led));
}
return lev;
}
void TxRef::unserialize(BinaryRefReader & brr)
{
unserialize(brr.getCurrPtr());
brr.advance(nBytes_);
}
void BlockHeader::unserialize(BinaryRefReader & brr)
{
unserialize(brr.get_BinaryDataRef(HEADER_SIZE));
}
void Tx::unserialize(BinaryRefReader & brr)
{
unserialize(brr.getCurrPtr(), brr.getSizeRemaining());
brr.advance(getSize());
}
