bool incentive_vote::decode(data_buffer & buffer) { /** * Read the version. */ m_version = buffer.read_uint32(); assert(m_version == current_version); /** * Read the block height. */ m_block_height = buffer.read_uint32(); /** * Read the block hash. */ m_hash_block = buffer.read_sha256(); /** * Read the nonce hash. */ m_hash_nonce = buffer.read_sha256(); /** * Read the number of address length. */ auto address_len = buffer.read_var_int(); /** * Allocate the address. */ m_address.resize(address_len); /** * Read the address. */ buffer.read_bytes(const_cast<char *>(m_address.data()), m_address.size()); /** * Decode the public key. */ m_public_key.decode(buffer); /** * Check the hash nonce is correct. */ if ( m_hash_nonce != (m_hash_block ^ sha256::from_digest(&hash::sha256d( reinterpret_cast<const std::uint8_t *> ( m_address.data()), m_address.size())[0]) ^ m_public_key.get_hash()) ) { log_error("Incentive vote decode failed, invalid nonce."); return false; } return verify(buffer); }
bool hd_configuration::decode(data_buffer & buffer) { m_version = buffer.read_uint32(); m_index = buffer.read_uint32(); buffer.read_bytes( reinterpret_cast<char *> (&m_id_key_master.digest()[0]), ripemd160::digest_length ); return true; }
bool zerotime_question::decode(data_buffer & buffer) { /** * Decode the version. */ m_version = buffer.read_uint32(); assert(m_version == current_version); /** * Decode the transaction inputs length. */ auto len = buffer.read_var_int(); /** * Allocate the transaction inputs. */ m_transactions_in.resize(len); for (auto i = 0; i < len; i++) { /** * Decode the transaction_in. */ m_transactions_in[i].decode(buffer); } return true; }
bool inventory_vector::decode(data_buffer & buffer) { m_type = static_cast<type_t> (buffer.read_uint32()); m_hash = buffer.read_sha256(); return true; }
bool merkle_tree_partial::decode(data_buffer & buffer) { m_total_transactions = buffer.read_uint32(); auto count = buffer.read_var_int(); for (auto i = 0; i < count; i++) { m_hashes.push_back(buffer.read_sha256()); } std::vector<std::uint8_t> bytes; auto len = buffer.read_var_int(); if (len > 0) { bytes.resize(len); buffer.read_bytes(reinterpret_cast<char *>(&bytes[0]), len); } m_flags.resize(bytes.size() * 8); for (auto i = 0; i < m_flags.size(); i++) { m_flags[i] = (bytes[i / 8] & (1 << (i % 8))) != 0; } is_invalid_ = false; return true; }
void key_wallet::decode(data_buffer & buffer) { /** * Read the version. */ buffer.read_uint32(); /** * Read the private key length. */ auto len = buffer.read_var_int(); if (len > 0) { /** * Read the private key. */ m_key_private.reserve(len); buffer.read_bytes( reinterpret_cast<char *> (&m_key_private[0]), m_key_private.size() ); } /** * Read the time created. */ m_time_created = buffer.read_int64(); /** * Read the time expires. */ m_time_expires = buffer.read_int64(); /** * Read the comment length. */ len = buffer.read_var_int(); if (len > 0) { /** * Read the comment. */ m_comment.reserve(len); buffer.read_bytes( const_cast<char *> (m_comment.data()), m_comment.size() ); } }
bool zerotime_lock::decode(data_buffer & buffer) { /** * Decode the version. */ m_version = buffer.read_uint32(); assert(m_version == current_version); /** * Decode the transaction. */ m_transaction.decode(buffer); /** * Decode the transaction hash. */ buffer.read_bytes( reinterpret_cast<char *> (m_hash_tx.digest()), sha256::digest_length ); assert(m_transaction.get_hash() == m_hash_tx); /** * Decode the expiration. */ m_expiration = buffer.read_uint64(); /** * Enforce the expiration. */ if ( m_expiration < time::instance().get_adjusted() + interval_min_expire || m_expiration > time::instance().get_adjusted() + interval_max_expire ) { m_expiration = time::instance().get_adjusted() + interval_min_expire; } /** * No signature is required because: * 1. The receiver may want to lock a non-zerotime transaction. * 2. It causes no harm to let other's lock the transaction. * 3. It conserves bandwidth and processing power. */ return m_transaction.get_hash() == m_hash_tx; }
void key_pool::decode(data_buffer & buffer, const bool & include_version) { if (include_version) { /** * Read the version. */ buffer.read_uint32(); } /** * Read the time. */ m_time = buffer.read_int64(); /** * Decode the public key. */ m_key_public.decode(buffer); }
bool incentive_answer::decode(data_buffer & buffer) { /** * Decode the version. */ m_version = buffer.read_uint32(); assert(m_version == current_version); /** * Decode the key_public. */ m_public_key.decode(buffer); /** * Decode the transaction_in. */ m_transaction_in.decode(buffer); return verify(buffer); }
bool chainblender_join::decode(data_buffer & buffer) { /** * Decode the version. */ m_version = buffer.read_uint32(); assert(m_version == current_version); /** * Decode the session id. */ m_hash_session_id = buffer.read_sha256(); /** * Read the denomination. */ m_denomination = buffer.read_int64(); return true; }
bool db_wallet::read_key_value( wallet & w, data_buffer & buffer_key, data_buffer & buffer_value, std::int32_t & file_version, std::vector<sha256> & wallet_upgrade, bool & is_encrypted, bool & any_unordered, std::string & type, std::string & err ) { type.clear(); type.resize(buffer_key.read_var_int()); buffer_key.read_bytes( const_cast<char *> (type.data()), type.size() ); if (type == "name") { std::string addr; auto len = buffer_key.read_var_int(); if (len > 0) { addr.resize(len); buffer_key.read_bytes( const_cast<char *> (addr.data()), addr.size() ); } std::string value; len = buffer_value.read_var_int(); if (len > 0) { value.resize(len); buffer_value.read_bytes( const_cast<char *> (value.data()), value.size() ); } w.address_book()[address(addr).get()] = value; } else if (type == "tx") { sha256 hash = buffer_key.read_sha256(); auto & wtx = w.transactions()[hash]; wtx.decode(buffer_value); if (wtx.get_hash() == hash) { wtx.bind_wallet(w); } else { w.transactions().erase(hash); return false; } /** * Undo serialize changes in 31600. */ if ( 31404 <= wtx.time_received_is_tx_time() && wtx.time_received_is_tx_time() <= 31703 ) { if (buffer_value.remaining() > 0) { char tmp; char unused; buffer_value.read_bytes(&tmp, sizeof(tmp)); buffer_value.read_bytes(&unused, sizeof(unused)); wtx.from_account().clear(); wtx.from_account().resize(buffer_value.read_var_int()); buffer_value.read_bytes( const_cast<char *> (wtx.from_account().data()), wtx.from_account().size() ); wtx.set_time_received_is_tx_time(tmp); } else { wtx.set_time_received_is_tx_time(0); } wallet_upgrade.push_back(hash); } if (wtx.order_position() == -1) { any_unordered = true; } } else if (type == "acentry") { std::string acct; auto len = buffer_key.read_var_int(); if (len > 0) { acct.resize(len); buffer_key.read_bytes( const_cast<char *> (acct.data()), acct.size() ); } std::uint64_t entry_number = buffer_key.read_uint64(); if (entry_number > g_accounting_entry_number) { g_accounting_entry_number = entry_number; } if (any_unordered == false) { accounting_entry entry; entry.decode(buffer_value); if (entry.order_position() == -1) { any_unordered = true; } } } else if (type == "key" || type == "wkey") { std::vector<std::uint8_t> pub_key; auto len_public_key = buffer_key.read_var_int(); if (len_public_key > 0) { pub_key.resize(len_public_key); buffer_key.read_bytes( reinterpret_cast<char *>(&pub_key[0]), pub_key.size() ); } key k; if (type == "key") { key::private_t pkey; auto len_private_key = buffer_value.read_var_int(); if (len_private_key > 0) { pkey.resize(len_private_key); buffer_value.read_bytes( reinterpret_cast<char *>(&pkey[0]), pkey.size() ); } k.set_public_key(pub_key); if (k.set_private_key(pkey) == false) { err = "private key is corrupt"; return false; } if (k.get_public_key() != pub_key) { err = "public key inconsistency"; return false; } if (k.is_valid() == false) { err = "invalid private key"; return false; } } else { key_wallet wkey; wkey.decode(buffer_value); k.set_public_key(pub_key); if (k.set_private_key(wkey.key_private()) == false) { err = "private key is corrupt"; return false; } if (k.get_public_key() != pub_key) { err = "public key inconsistency"; return false; } if (k.is_valid() == false) { err = "invalid wallet key"; return false; } } if (w.load_key(k) == false) { err = "load key failed"; return false; } } else if (type == "mkey") { auto id = buffer_key.read_uint32(); key_wallet_master master_key; master_key.decode(buffer_value); if (w.master_keys().count(id) != 0) { err = "duplicate master key id " + std::to_string(id); return false; } w.master_keys()[id] = master_key; if (w.master_key_max_id() < id) { w.set_master_key_max_id(id); } } else if (type == "ckey") { std::vector<std::uint8_t> pub_key; auto len = buffer_key.read_var_int(); if (len > 0) { pub_key.resize(len); buffer_key.read_bytes( reinterpret_cast<char *> (&pub_key[0]), pub_key.size() ); } std::vector<std::uint8_t> pri_key; len = buffer_value.read_var_int(); if (len > 0) { pri_key.resize(len); buffer_value.read_bytes( reinterpret_cast<char *> (&pri_key[0]), pri_key.size() ); } if (w.load_crypted_key(pub_key, pri_key) == false) { err = "load crypted key failed"; return false; } is_encrypted = true; } else if (type == "defaultkey") { /** * Allocate the default public key. */ key_public key_public_default; /** * Decode the default public key. */ if (key_public_default.decode(buffer_value)) { /** * Set the default public key. */ w.set_key_public_default(key_public_default); } } else if (type == "pool") { auto index = buffer_key.read_int64(); w.get_key_pool().insert(index); } else if (type == "version") { file_version = buffer_value.read_uint32(); if (file_version == 10300) { file_version = 300; } } else if (type == "cscript") { auto digest = buffer_key.read_bytes(ripemd160::digest_length); auto len = buffer_value.read_var_int(); if (len > 0) { script s(len); buffer_value.read_bytes(reinterpret_cast<char *> (&s[0]), s.size()); if (w.load_c_script(s) == false) { err = "load c script failed"; return false; } } } else if (type == "orderposnext") { std::int64_t order_position_next = buffer_value.read_int64(); w.set_order_position_next(order_position_next); } return true; }
bool transaction::decode(data_buffer & buffer) { /** * Read the version. */ m_version = buffer.read_uint32(); /** * Read the time. */ m_time = buffer.read_uint32(); /** * Read the number of transactions in. */ auto number_transactions_in = buffer.read_var_int(); for (auto i = 0; i < number_transactions_in; i++) { /** * Allocate the transaction_in. */ transaction_in tx_in; /** * Decode the transaction_in. */ tx_in.decode(buffer); /** * Retain the transaction_in. */ m_transactions_in.push_back(tx_in); } /** * Read the number of transactions out. */ auto number_transactions_out = buffer.read_var_int(); for (auto i = 0; i < number_transactions_out; i++) { /** * Allocate the transaction_out. */ transaction_out tx_out; /** * Decode the transaction_out. */ tx_out.decode(buffer); /** * Retain the transaction_out. */ m_transactions_out.push_back(tx_out); } /** * Decode the time lock. */ m_time_lock = buffer.read_uint32(); return true; }
bool incentive_collaterals::decode(data_buffer & buffer) { /** * Decode the version. */ m_version = buffer.read_uint32(); assert(m_version == current_version); /** * Read the number of collateral entries. */ auto count = buffer.read_var_int(); /** * Read each collateral entry. */ for (auto i = 0; i < count; i++) { address_manager::recent_endpoint_t collateral; /** * Read the address. */ collateral.addr = buffer.read_network_address(false, true); auto len = buffer.read_var_int(); collateral.wallet_address.resize(len); /** * Read the wallet address. */ buffer.read_bytes( const_cast<char *> (collateral.wallet_address.data()), collateral.wallet_address.size() ); /** * Read the public key. */ collateral.public_key.decode(buffer); /** * Read the transaction_in. */ collateral.tx_in.decode(buffer); /** * Read the time. */ collateral.time = buffer.read_uint64(); /** * Read the protocol version. */ collateral.protocol_version = buffer.read_uint32(); /** * Read the protocol version user agent length. */ len = buffer.read_var_int(); collateral.protocol_version_user_agent.resize(len); /** * Read the protocol version user agent. */ buffer.read_bytes( const_cast<char *> (collateral.protocol_version_user_agent.data()), collateral.protocol_version_user_agent.size() ); /** * Read the protocol version services. */ collateral.protocol_version_services = buffer.read_uint64(); /** * Read the protocol version start height. */ collateral.protocol_version_start_height = buffer.read_int32(); m_collaterals.insert(collateral); } return true; }
void transaction_wallet::decode(data_buffer & buffer) { /** * Initialize */ initialize(0); auto is_spent = false; /** * Decode the base class. */ transaction_merkle::decode(buffer); auto len = buffer.read_var_int(); for (auto i = 0; i < len; i++) { transaction_merkle tx_merkle; tx_merkle.decode(buffer); m_previous_transactions.push_back(tx_merkle); } auto len_values = buffer.read_var_int(); for (auto i = 0; i < len_values; i++) { std::string first(buffer.read_var_int(), 0); buffer.read_bytes(const_cast<char *> (first.data()), first.size()); std::string second(buffer.read_var_int(), 0); buffer.read_bytes(const_cast<char *> (second.data()), second.size()); m_values[first] = second; } m_order_form.resize(buffer.read_var_int()); for (auto i = 0; i < m_order_form.size(); i++) { std::string first(buffer.read_var_int(), 0); buffer.read_bytes(const_cast<char *> (first.data()), first.size()); std::string second(buffer.read_var_int(), 0); buffer.read_bytes(const_cast<char *> (second.data()), second.size()); m_order_form[i] = std::make_pair(first, second); } m_time_received_is_tx_time = buffer.read_uint32(); m_time_received = buffer.read_uint32(); m_is_from_me = buffer.read_uint8(); is_spent = buffer.read_uint8(); m_from_account = m_values["fromaccount"]; if (m_values.count("spent") > 0) { for (auto & i : m_values["spent"]) { m_spent.push_back(i != '0'); } } else { m_spent.assign(transaction_out().size(), is_spent); } /** * If we are an (SPV) client set the block height from the value. */ if (globals::instance().is_client_spv() == true) { if (m_values.count("spv_block_height") > 0) { auto block_height = std::stoi(m_values["spv_block_height"]); set_spv_block_height(block_height); } } /** * Read the order position. */ wallet::read_order_position(m_order_position, m_values); m_time_smart = m_values.count("timesmart") ? boost::lexical_cast<std::uint32_t> (m_values["timesmart"]) : 0 ; m_values.erase("version"); m_values.erase("spent"); m_values.erase("n"); m_values.erase("timesmart"); }