C++ (Cpp) BinaryWriter::put_var_int Examples

Example #1

File: DataObject.cpp Project: achow101/BitcoinArmory

void LedgerEntryVector::serialize(BinaryWriter& bw) const
{
   bw.put_uint8_t(LEDGERENTRYVECTOR_CODE);
   bw.put_var_int(leVec_.size());

   for (auto& le : leVec_)
   {
      auto idSize = le.ID_.size();
      size_t totalsize = idSize + 53;
      bw.put_var_int(totalsize);

      bw.put_var_int(idSize);
      bw.put_BinaryData((uint8_t*)le.ID_.c_str(), idSize);
      
      bw.put_uint64_t(le.value_);
      bw.put_uint32_t(le.blockNum_);
      bw.put_BinaryData(le.txHash_);
      bw.put_uint32_t(le.index_);
      bw.put_uint32_t(le.txTime_);

      BitPacker<uint8_t> bp;
      bp.putBit(le.isCoinbase_);
      bp.putBit(le.isSentToSelf_);
      bp.putBit(le.isChangeBack_);
      bp.putBit(le.optInRBF_);

      bw.put_BitPacker(bp);
   }
}

Example #2

File: DataObject.cpp Project: achow101/BitcoinArmory

void BinaryDataVector::serialize(BinaryWriter& bw) const
{
   bw.put_uint8_t(BINARYDATAVECTOR_CODE);
   size_t size = 0;
   for (auto& bdo : bdVec_)
      size += bdo.getSize();

   bw.put_var_int(size);
   bw.put_var_int(bdVec_.size());

   for (auto& bdo : bdVec_)
   {
      bw.put_var_int(bdo.getSize());
      bw.put_BinaryData(bdo);
   }
}

Example #3

File: Script.cpp Project: Rudd-O/BitcoinArmory

BinaryData StackItem_MultiSig::serialize(void) const
{
   BinaryWriter bw;
   bw.put_uint32_t(id_);
   bw.put_uint8_t(STACKITEM_MULTISIG_PREFIX);
   bw.put_uint16_t(m_);
   bw.put_var_int(sigs_.size());
   
   for (auto& sig_pair : sigs_)
   {
      bw.put_uint16_t(sig_pair.first);
      bw.put_var_int(sig_pair.second.getSize());
      bw.put_BinaryData(sig_pair.second);
   }

   return bw.getData();
}

Example #4

File: Script.cpp Project: Rudd-O/BitcoinArmory

BinaryData StackItem_PushData::serialize(void) const
{
   BinaryWriter bw;
   bw.put_uint32_t(id_);
   bw.put_uint8_t(STACKITEM_PUSHDATA_PREFIX);
   bw.put_var_int(data_.getSize());
   bw.put_BinaryData(data_);

   return bw.getData();
}

Example #5

File: Script.cpp Project: Rudd-O/BitcoinArmory

BinaryData StackItem_SerializedScript::serialize(void) const
{
   BinaryWriter bw;
   bw.put_uint32_t(id_);
   bw.put_uint8_t(STACKITEM_SERSCRIPT_PREFIX);
   bw.put_var_int(data_.getSize());
   bw.put_BinaryData(data_);

   return bw.getData();
}

Example #6

File: BlockObjRef.cpp Project: Ajaydhyani/PyBtcEngine

BinaryData BlockHeaderRef::serializeWholeBlock(bool withLead8Bytes) const
{
   BinaryWriter serializedBlock;
   uint32_t blksize = getBlockSize();
   if(withLead8Bytes)
   {
      serializedBlock.reserve(blksize + 8);
      serializedBlock.put_BinaryData(BtcUtils::MagicBytes_);
      serializedBlock.put_uint32_t(blksize);
   }
   else
      serializedBlock.reserve(blksize);

   serializedBlock.put_BinaryData(self_);
   serializedBlock.put_var_int(getNumTx());
   for(uint32_t i=0; i<getNumTx(); i++)
      serializedBlock.put_BinaryData(txPtrList_[i]->serialize());

   return serializedBlock.getData();
   
}

Example #7

File: DataObject.cpp Project: achow101/BitcoinArmory

void IntType::serialize(BinaryWriter& bw) const
{
   bw.put_uint8_t(INTTYPE_CODE);
   bw.put_var_int(val_);
}

Example #8

File: DataObject.cpp Project: achow101/BitcoinArmory

void ErrorType::serialize(BinaryWriter& bw) const
{
   bw.put_uint8_t(ERRTYPE_CODE);
   bw.put_var_int(err_.size());
   bw.put_BinaryData((uint8_t*)err_.c_str(), err_.size());
}

Example #9

File: DataObject.cpp Project: achow101/BitcoinArmory

void BinaryDataObject::serialize(BinaryWriter& bw) const
{
   bw.put_uint8_t(BINARYDATAOBJECT_CODE);
   bw.put_var_int(bd_.getSize());
   bw.put_BinaryData(bd_);
}

Example #10

File: Transactions.cpp Project: yurivict/BitcoinArmory

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());
}