Common.h

Go to the documentation of this file.

/*
    This file is part of cpp-ethereum.

    cpp-ethereum is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    cpp-ethereum is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once

#include <libdevcore/Address.h>
#include <libdevcore/Common.h>
#include <libdevcore/Exceptions.h>
#include <libdevcore/FixedHash.h>

#include <functional>
#include <string>

namespace dev
{

class RLP;
class RLPStream;

namespace eth
{

extern const unsigned c_protocolVersion;

extern const unsigned c_minorProtocolVersion;

extern const unsigned c_databaseVersion;

extern const Address c_blockhashContractAddress;
extern const bytes c_blockhashContractCode;

std::string formatBalance(bigint const& _b);

DEV_SIMPLE_EXCEPTION(InvalidAddress);

Address toAddress(std::string const& _s);

std::vector<std::pair<u256, std::string>> const& units();

using LogBloom = h2048;

using LogBlooms = std::vector<LogBloom>;

// The various denominations; here for ease of use where needed within code.
static const u256 ether = exp10<18>();
static const u256 finney = exp10<15>();
static const u256 szabo = exp10<12>();
static const u256 shannon = exp10<9>();
static const u256 wei = exp10<0>();

using Nonce = h64;

using BlockNumber = unsigned;

static const BlockNumber LatestBlock = (BlockNumber)-2;
static const BlockNumber PendingBlock = (BlockNumber)-1;
static const h256 LatestBlockHash = h256(2);
static const h256 EarliestBlockHash = h256(1);
static const h256 PendingBlockHash = h256(0);

static const u256 DefaultBlockGasLimit = 4712388;

enum class RelativeBlock: BlockNumber
{
    Latest = LatestBlock,
    Pending = PendingBlock
};

enum class BlockPolarity
{
    Unknown,
    Dead,
    Live
};

class Transaction;

struct ImportRoute
{
    h256s deadBlocks;
    h256s liveBlocks;
    std::vector<Transaction> goodTranactions;
};

enum class ImportResult
{
    Success = 0,
    UnknownParent,
    FutureTimeKnown,
    FutureTimeUnknown,
    AlreadyInChain,
    AlreadyKnown,
    Malformed,
    OverbidGasPrice,
    BadChain,
    ZeroSignature
};

struct ImportRequirements
{
    using value = unsigned;
    enum
    {
        ValidSeal = 1, 
        UncleBasic = 4, 
        TransactionBasic = 8, 
        UncleSeals = 16, 
        TransactionSignatures = 32, 
        Parent = 64, 
        UncleParent = 128, 
        PostGenesis = 256, 
        CheckUncles = UncleBasic | UncleSeals, 
        CheckTransactions = TransactionBasic | TransactionSignatures, 
        OutOfOrderChecks = ValidSeal | CheckUncles | CheckTransactions, 
        InOrderChecks = Parent | UncleParent, 
        Everything = ValidSeal | CheckUncles | CheckTransactions | Parent | UncleParent,
        None = 0
    };
};

template<typename... Args> class Signal
{
public:
    using Callback = std::function<void(Args...)>;

    class HandlerAux
    {
        friend class Signal;

    public:
        ~HandlerAux() { if (m_s) m_s->m_fire.erase(m_i); }
        void reset() { m_s = nullptr; }
        void fire(Args const&... _args) { m_h(_args...); }

    private:
        HandlerAux(unsigned _i, Signal* _s, Callback const& _h): m_i(_i), m_s(_s), m_h(_h) {}

        unsigned m_i = 0;
        Signal* m_s = nullptr;
        Callback m_h;
    };

    ~Signal()
    {
        for (auto const& h : m_fire)
            if (auto l = h.second.lock())
                l->reset();
    }

    std::shared_ptr<HandlerAux> add(Callback const& _h)
    {
        auto n = m_fire.empty() ? 0 : (m_fire.rbegin()->first + 1);
        auto h =  std::shared_ptr<HandlerAux>(new HandlerAux(n, this, _h));
        m_fire[n] = h;
        return h;
    }

    void operator()(Args const&... _args)
    {
        for (auto const& f: valuesOf(m_fire))
            if (auto h = f.lock())
                h->fire(_args...);
    }

private:
    std::map<unsigned, std::weak_ptr<typename Signal::HandlerAux>> m_fire;
};

template<class... Args> using Handler = std::shared_ptr<typename Signal<Args...>::HandlerAux>;

struct TransactionSkeleton
{
    bool creation = false;
    Address from;
    Address to;
    u256 value;
    bytes data;
    u256 nonce = Invalid256;
    u256 gas = Invalid256;
    u256 gasPrice = Invalid256;

    std::string userReadable(bool _toProxy, std::function<std::pair<bool, std::string>(TransactionSkeleton const&)> const& _getNatSpec, std::function<std::string(Address const&)> const& _formatAddress) const;
};


void badBlock(bytesConstRef _header, std::string const& _err);
inline void badBlock(bytes const& _header, std::string const& _err) { badBlock(&_header, _err); }

// TODO: move back into a mining subsystem and have it be accessible from Sealant only via a dynamic_cast.
struct WorkingProgress
{
//  MiningProgress& operator+=(MiningProgress const& _mp) { hashes += _mp.hashes; ms = std::max(ms, _mp.ms); return *this; }
    uint64_t hashes = 0;        
    uint64_t ms = 0;            
    u256 rate() const { return ms == 0 ? 0 : hashes * 1000 / ms; }
};

enum class IfDropped
{
    Ignore, 
    Retry   
};

}
}