Transaction.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 <libethcore/Common.h>
#include <libethcore/TransactionBase.h>
#include <libethcore/ChainOperationParams.h>
#include <libdevcore/RLP.h>
#include <libdevcore/SHA3.h>
 
namespace dev
{
namespace eth
{
 
enum class TransactionException
{
    None = 0,
    Unknown,
    BadRLP,
    InvalidFormat,
    OutOfGasIntrinsic,      
    InvalidSignature,
    InvalidNonce,
    NotEnoughCash,
    OutOfGasBase,           
    BlockGasLimitReached,
    BadInstruction,
    BadJumpDestination,
    OutOfGas,               
    OutOfStack,             
    StackUnderflow,
    RevertInstruction,
    InvalidZeroSignatureFormat,
    AddressAlreadyUsed
};
 
enum class CodeDeposit
{
    None = 0,
    Failed,
    Success
};
 
struct VMException;
 
TransactionException toTransactionException(Exception const& _e);
std::ostream& operator<<(std::ostream& _out, TransactionException const& _er);
 
struct ExecutionResult
{
    u256 gasUsed = 0;
    TransactionException excepted = TransactionException::Unknown;
    Address newAddress;
    bytes output;
    CodeDeposit codeDeposit = CodeDeposit::None;                    
    u256 gasRefunded = 0;
    unsigned depositSize = 0;                                       
    u256 gasForDeposit;                                             
};
 
std::ostream& operator<<(std::ostream& _out, ExecutionResult const& _er);
 
class Transaction: public TransactionBase
{
public:
    Transaction() {}
 
    Transaction(TransactionSkeleton const& _ts, Secret const& _s = Secret()): TransactionBase(_ts, _s) {}
 
    Transaction(u256 const& _value, u256 const& _gasPrice, u256 const& _gas, Address const& _dest, bytes const& _data, u256 const& _nonce, Secret const& _secret):
        TransactionBase(_value, _gasPrice, _gas, _dest, _data, _nonce, _secret)
    {}
 
    Transaction(u256 const& _value, u256 const& _gasPrice, u256 const& _gas, bytes const& _data, u256 const& _nonce, Secret const& _secret):
        TransactionBase(_value, _gasPrice, _gas, _data, _nonce, _secret)
    {}
 
    Transaction(u256 const& _value, u256 const& _gasPrice, u256 const& _gas, Address const& _dest, bytes const& _data, u256 const& _nonce = Invalid256):
        TransactionBase(_value, _gasPrice, _gas, _dest, _data, _nonce)
    {}
 
    Transaction(u256 const& _value, u256 const& _gasPrice, u256 const& _gas, bytes const& _data, u256 const& _nonce = Invalid256):
        TransactionBase(_value, _gasPrice, _gas, _data, _nonce)
    {}
 
    explicit Transaction(bytesConstRef _rlp, CheckTransaction _checkSig);
 
    explicit Transaction(bytes const& _rlp, CheckTransaction _checkSig): Transaction(&_rlp, _checkSig) {}
};
 
using Transactions = std::vector<Transaction>;
 
class LocalisedTransaction: public Transaction
{
public:
    LocalisedTransaction(
        Transaction const& _t,
        h256 const& _blockHash,
        unsigned _transactionIndex,
        BlockNumber _blockNumber = 0
    ):
        Transaction(_t),
        m_blockHash(_blockHash),
        m_transactionIndex(_transactionIndex),
        m_blockNumber(_blockNumber)
    {}
 
    h256 const& blockHash() const { return m_blockHash; }
    unsigned transactionIndex() const { return m_transactionIndex; }
    BlockNumber blockNumber() const { return m_blockNumber; }
 
private:
    h256 m_blockHash;
    unsigned m_transactionIndex;
    BlockNumber m_blockNumber;
};
 
}
}