      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

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

    //! Evm input params.
    use util::{Address, Bytes, Uint, U256};
    use util::hash::{H256, FixedHash};
    use util::sha3::{Hashable, SHA3_EMPTY};
    use ethjson;
    use types::executed::CallType;

    use std::sync::Arc;

    /// Transaction value
    #[derive(Clone, Debug)]
    pub enum ActionValue {
    	/// Value that should be transfered
    	Transfer(U256),
    	/// Apparent value for transaction (not transfered)
    	Apparent(U256)
    }

    impl ActionValue {
    	/// Returns action value as U256.
    	pub fn value(&self) -> U256 {
    		match *self {
    			ActionValue::Transfer(x) | ActionValue::Apparent(x) => x
    		}
    	}
    }

    // TODO: should be a trait, possible to avoid cloning everything from a Transaction(/View).
    /// Action (call/create) input params. Everything else should be specified in Externalities.
    #[derive(Clone, Debug)]
    pub struct ActionParams {
    	/// Address of currently executed code.
    	pub code_address: Address,
    	/// Hash of currently executed code.
    	pub code_hash: H256,
    	/// Receive address. Usually equal to code_address,
    	/// except when called using CALLCODE.
    	pub address: Address,
    	/// Sender of current part of the transaction.
    	pub sender: Address,
    	/// Transaction initiator.
    	pub origin: Address,
    	/// Gas paid up front for transaction execution
    	pub gas: U256,
    	/// Gas price.
    	pub gas_price: U256,
    	/// Transaction value.
    	pub value: ActionValue,
    	/// Code being executed.
    	pub code: Option<Arc<Bytes>>,
    	/// Input data.
    	pub data: Option<Bytes>,
    	/// Type of call
    	pub call_type: CallType,

    }

    impl Default for ActionParams {
    	/// Returns default ActionParams initialized with zeros
    	fn default() -> ActionParams {
    		ActionParams {
    			code_address: Address::new(),
    			code_hash: SHA3_EMPTY,
    			address: Address::new(),
    			sender: Address::new(),
    			origin: Address::new(),
    			gas: U256::zero(),
    			gas_price: U256::zero(),
    			value: ActionValue::Transfer(U256::zero()),
    			code: None,
    			data: None,
    			call_type: CallType::None,
    		}
    	}
    }

    impl From<ethjson::vm::Transaction> for ActionParams {
    	fn from(t: ethjson::vm::Transaction) -> Self {
    		let address: Address = t.address.into();
    		ActionParams {
    			code_address: Address::new(),
    			code_hash: (&*t.code).sha3(),
    			address: address,
    			sender: t.sender.into(),
    			origin: t.origin.into(),
    			code: Some(Arc::new(t.code.into())),
    			data: Some(t.data.into()),
    			gas: t.gas.into(),
    			gas_price: t.gas_price.into(),
    			value: ActionValue::Transfer(t.value.into()),
    			call_type: match address.is_zero() { true => CallType::None, false => CallType::Call },	// TODO @debris is this correct?
    		}
    	}
    }

# 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`)