C++ data_buffer::read_sha256方法代码示例

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 checkpoint_sync_unsigned::decode(data_buffer & buffer)
{
    m_version = buffer.read_int32();
    m_hash_checkpoint = buffer.read_sha256();
    
    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;
}

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;
//.........这里部分代码省略.........