Non-canonical state-change parameter

ethcore/src/machine.rs

@@ -26,7 +26,7 @@ use client::{BlockInfo, CallContract};
 use error::Error;
 use executive::Executive;
 use header::{BlockNumber, Header};
-use spec::CommonParams;
+use spec::{CommonParams, IrregularStateChangeAccount};
 use state::{CleanupMode, Substate};
 use trace::{NoopTracer, NoopVMTracer, Tracer, ExecutiveTracer, RewardType, Tracing};
 use transaction::{self, SYSTEM_ADDRESS, UnverifiedTransaction, SignedTransaction};
@@ -193,6 +193,30 @@ impl EthereumMachine {
 						.and_then(|b| state.transfer_balance(child, beneficiary, &b, CleanupMode::NoEmpty))?;
 				}
 			}
+
+			if let Some(irregular_changes) = self.params.irregular_state_changes.get(&block.header().number()) {
+				let state = block.state_mut();
+				for &(address, ref irregular_account) in irregular_changes {
+					match irregular_account {
+						&IrregularStateChangeAccount::Set {
+							nonce, balance, ref code, ref storage
+						} => {
+							if let Some(nonce) = nonce {
+								state.set_nonce(&address, &nonce)?;
+							}
+							if let Some(balance) = balance {
+								state.set_balance(&address, &balance)?;
+							}
+							if let &Some(ref code) = code {
+								state.reset_code(&address, code.clone())?;
+							}
+							for &(key, value) in storage {
+								state.set_storage(&address, key, value)?;
+							}
+						},
+					}
+				}
+			}
 		}
 
 		Ok(())

ethcore/src/spec/mod.rs

@@ -21,4 +21,4 @@ mod seal;
 mod spec;
 
 pub use self::genesis::Genesis;
-pub use self::spec::{Spec, SpecHardcodedSync, SpecParams, CommonParams, OptimizeFor};
+pub use self::spec::{Spec, SpecHardcodedSync, SpecParams, CommonParams, OptimizeFor, IrregularStateChangeAccount};

ethcore/src/spec/spec.rs

@@ -16,7 +16,7 @@
 
 //! Parameters for a block chain.
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 use std::io::Read;
 use std::path::Path;
 use std::sync::Arc;
@@ -53,6 +53,39 @@ fn fmt_err<F: ::std::fmt::Display>(f: F) -> String {
 	format!("Spec json is invalid: {}", f)
 }
 
+/// Ireegular state change accounts applied at specific blocks.
+#[derive(Debug, Clone, PartialEq)]
+pub enum IrregularStateChangeAccount {
+	/// Force setting values on an account.
+	Set {
+		/// New nonce forced setting.
+		nonce: Option<U256>,
+		/// New code forced setting.
+		code: Option<Bytes>,
+		/// New balance forced setting.
+		balance: Option<U256>,
+		/// Storage values forced setting.
+		storage: Vec<(H256, H256)>,
+	}
+}
+
+impl From<::ethjson::spec::IrregularStateChangeAccount> for IrregularStateChangeAccount {
+	fn from(p: ::ethjson::spec::IrregularStateChangeAccount) -> Self {
+		match p {
+			::ethjson::spec::IrregularStateChangeAccount::Set {
+				nonce, code, balance, storage
+			} => {
+				IrregularStateChangeAccount::Set {
+					nonce: nonce.map(Into::into),
+					code: code.map(Into::into),
+					balance: balance.map(Into::into),
+					storage: storage.unwrap_or_default().into_iter().map(|(k, v)| (k.into(), v.into())).collect(),
+				}
+			},
+		}
+	}
+}
+
 /// Parameters common to ethereum-like blockchains.
 /// NOTE: when adding bugfix hard-fork parameters,
 /// add to `contains_bugfix_hard_fork`
@@ -123,6 +156,8 @@ pub struct CommonParams {
 	pub max_code_size_transition: BlockNumber,
 	/// Transaction permission managing contract address.
 	pub transaction_permission_contract: Option<Address>,
+	/// Irregular state change list.
+	pub irregular_state_changes: HashMap<u64, Vec<(Address, IrregularStateChangeAccount)>>,
 }
 
 impl CommonParams {
@@ -244,6 +279,7 @@ impl From<ethjson::spec::Params> for CommonParams {
 				BlockNumber::max_value(),
 				Into::into
 			),
+			irregular_state_changes: p.irregular_state_changes.unwrap_or_else(HashMap::new).into_iter().map(|(k, v)| (k.into(), v.into_iter().map(|(k, v)| (k.into(), v.into())).collect())).collect(),
 		}
 	}
 }

ethcore/src/state/account.rs

@@ -349,6 +349,11 @@ impl Account {
 		self.nonce = self.nonce + U256::from(1u8);
 	}
 
+	/// Set the nonce of the account to a particular value.
+	pub fn set_nonce(&mut self, nonce: &U256) {
+		self.nonce = *nonce;
+	}
+
 	/// Increase account balance.
 	pub fn add_balance(&mut self, x: &U256) {
 		self.balance = self.balance + *x;
@@ -361,6 +366,11 @@ impl Account {
 		self.balance = self.balance - *x;
 	}
 
+	/// Directly set the account balance.
+	pub fn set_balance(&mut self, x: &U256) {
+		self.balance = *x;
+	}
+
 	/// Commit the `storage_changes` to the backing DB and update `storage_root`.
 	pub fn commit_storage(&mut self, trie_factory: &TrieFactory, db: &mut HashDB) -> trie::Result<()> {
 		let mut t = trie_factory.from_existing(db, &mut self.storage_root)?;

ethcore/src/state/mod.rs

@@ -652,6 +652,12 @@ impl<B: Backend> State<B> {
 		Ok(())
 	}
 
+	/// Directly set the balance of account `a`.
+	pub fn set_balance(&mut self, a: &Address, bala: &U256) -> trie::Result<()> {
+		self.require(a, false)?.set_balance(bala);
+		Ok(())
+	}
+
 	/// Subtracts `by` from the balance of `from` and adds it to that of `to`.
 	pub fn transfer_balance(&mut self, from: &Address, to: &Address, by: &U256, mut cleanup_mode: CleanupMode) -> trie::Result<()> {
 		self.sub_balance(from, by, &mut cleanup_mode)?;
@@ -664,6 +670,11 @@ impl<B: Backend> State<B> {
 		self.require(a, false).map(|mut x| x.inc_nonce())
 	}
 
+	/// Set the nonce of an account.
+	pub fn set_nonce(&mut self, a: &Address, nonce: &U256) -> trie::Result<()> {
+		self.require(a, false).map(|mut x| x.set_nonce(nonce))
+	}
+
 	/// Mutate storage of account `a` so that it is `value` for `key`.
 	pub fn set_storage(&mut self, a: &Address, key: H256, value: H256) -> trie::Result<()> {
 		trace!(target: "state", "set_storage({}:{:x} to {:x})", a, key, value);

json/src/spec/mod.rs

@@ -35,7 +35,7 @@ pub mod hardcoded_sync;
 pub use self::account::Account;
 pub use self::builtin::{Builtin, Pricing, Linear};
 pub use self::genesis::Genesis;
-pub use self::params::Params;
+pub use self::params::{Params, IrregularStateChangeAccount};
 pub use self::spec::Spec;
 pub use self::seal::{Seal, Ethereum, AuthorityRoundSeal, TendermintSeal};
 pub use self::engine::Engine;

json/src/spec/params.rs

@@ -16,10 +16,35 @@
 
 //! Spec params deserialization.
 
+use std::collections::HashMap;
 use uint::{self, Uint};
 use hash::{H256, Address};
 use bytes::Bytes;
 
+/// See main CommonParams docs.
+#[derive(Clone, Debug, PartialEq, Deserialize)]
+pub enum IrregularStateChangeAccount {
+	/// See main CommonParams docs.
+	#[serde(rename="set")]
+	Set {
+		/// See main CommonParams docs.
+		#[serde(rename="nonce")]
+		nonce: Option<Uint>,
+
+		/// See main CommonParams docs.
+		#[serde(rename="code")]
+		code: Option<Bytes>,
+
+		/// See main CommonParams docs.
+		#[serde(rename="balance")]
+		balance: Option<Uint>,
+
+		/// See main CommonParams docs.
+		#[serde(rename="storage")]
+		storage: Option<HashMap<H256, H256>>,
+	}
+}
+
 /// Spec params.
 #[derive(Debug, PartialEq, Deserialize)]
 pub struct Params {
@@ -122,6 +147,9 @@ pub struct Params {
 	/// Wasm activation block height, if not activated from start
 	#[serde(rename="wasmActivationTransition")]
 	pub wasm_activation_transition: Option<Uint>,
+	/// See main CommonParams docs.
+	#[serde(rename="irregularStateChanges")]
+	pub irregular_state_changes: Option<HashMap<Uint, HashMap<Address, IrregularStateChangeAccount>>>,
 }
 
 #[cfg(test)]