      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126

    // Copyright 2015-2017 Parity Technologies (UK) Ltd.
    // This file is part of Parity.

    // Parity 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.

    // Parity 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 Parity.  If not, see <http://www.gnu.org/licenses/>.

    //! Interface for Evm externalities.

    use util::*;
    use evm::{self, Schedule};
    use env_info::*;
    use types::executed::CallType;

    /// Result of externalities create function.
    pub enum ContractCreateResult {
    	/// Returned when creation was successfull.
    	/// Contains an address of newly created contract and gas left.
    	Created(Address, U256),
    	/// Returned when contract creation failed.
    	/// VM doesn't have to know the reason.
    	Failed
    }

    /// Result of externalities call function.
    pub enum MessageCallResult {
    	/// Returned when message call was successfull.
    	/// Contains gas left.
    	Success(U256),
    	/// Returned when message call failed.
    	/// VM doesn't have to know the reason.
    	Failed
    }

    /// Externalities interface for EVMs
    pub trait Ext {
    	/// Returns a value for given key.
    	fn storage_at(&self, key: &H256) -> H256;

    	/// Stores a value for given key.
    	fn set_storage(&mut self, key: H256, value: H256);

    	/// Determine whether an account exists.
    	fn exists(&self, address: &Address) -> bool;

    	/// Determine whether an account exists and is not null (zero balance/nonce, no code).
    	fn exists_and_not_null(&self, address: &Address) -> bool;

    	/// Balance of the origin account.
    	fn origin_balance(&self) -> U256;

    	/// Returns address balance.
    	fn balance(&self, address: &Address) -> U256;

    	/// Returns the hash of one of the 256 most recent complete blocks.
    	fn blockhash(&self, number: &U256) -> H256;

    	/// Creates new contract.
    	///
    	/// Returns gas_left and contract address if contract creation was succesfull.
    	fn create(&mut self, gas: &U256, value: &U256, code: &[u8]) -> ContractCreateResult;

    	/// Message call.
    	///
    	/// Returns Err, if we run out of gas.
    	/// Otherwise returns call_result which contains gas left
    	/// and true if subcall was successfull.
    	#[cfg_attr(feature="dev", allow(too_many_arguments))]
    	fn call(&mut self,
    		gas: &U256,
    		sender_address: &Address,
    		receive_address: &Address,
    		value: Option<U256>,
    		data: &[u8],
    		code_address: &Address,
    		output: &mut [u8],
    		call_type: CallType
    	) -> MessageCallResult;

    	/// Returns code at given address
    	fn extcode(&self, address: &Address) -> Arc<Bytes>;

    	/// Returns code size at given address
    	fn extcodesize(&self, address: &Address) -> usize;

    	/// Creates log entry with given topics and data
    	fn log(&mut self, topics: Vec<H256>, data: &[u8]);

    	/// Should be called when transaction calls `RETURN` opcode.
    	/// Returns gas_left if cost of returning the data is not too high.
    	fn ret(self, gas: &U256, data: &[u8]) -> evm::Result<U256> where Self: Sized;

    	/// Should be called when contract commits suicide.
    	/// Address to which funds should be refunded.
    	fn suicide(&mut self, refund_address: &Address);

    	/// Returns schedule.
    	fn schedule(&self) -> &Schedule;

    	/// Returns environment info.
    	fn env_info(&self) -> &EnvInfo;

    	/// Returns current depth of execution.
    	///
    	/// If contract A calls contract B, and contract B calls C,
    	/// then A depth is 0, B is 1, C is 2 and so on.
    	fn depth(&self) -> usize;

    	/// Increments sstore refunds count by 1.
    	fn inc_sstore_clears(&mut self);

    	/// Prepare to trace an operation. Passthrough for the VM trace.
    	fn trace_prepare_execute(&mut self, _pc: usize, _instruction: u8, _gas_cost: &U256) -> bool { false }

    	/// Trace the finalised execution of a single instruction.
    	fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem_diff: Option<(usize, &[u8])>, _store_diff: Option<(U256, U256)>) {}
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)