Enumeratable accounts

demo/cli/src/lib.rs

@@ -122,6 +122,11 @@ pub fn run<I, T>(args: I) -> error::Result<()> where
 					intentions: vec![],
 					transaction_base_fee: 100,
 					transaction_byte_fee: 1,
+					transfer_fee: 0,
+					creation_fee: 0,
+					contract_fee: 0,
+					reclaim_rebate: 0,
+					existential_deposit: 500,
 					balances: vec![(god_key.clone().into(), 1u64 << 63)].into_iter().collect(),
 					validator_count: 12,
 					sessions_per_era: 24,	// 24 hours per era.

demo/executor/src/lib.rs

@@ -46,11 +46,12 @@ mod tests {
 	use runtime_support::{Hashable, StorageValue, StorageMap};
 	use state_machine::{CodeExecutor, TestExternalities};
 	use primitives::twox_128;
-	use demo_primitives::{Hash, BlockNumber};
+	use demo_primitives::{Hash, BlockNumber, AccountId};
 	use runtime_primitives::traits::Header as HeaderT;
+	use runtime_primitives::{ApplyOutcome, ApplyError, ApplyResult, MaybeUnsigned};
 	use {staking, system};
 	use demo_runtime::{Header, Block, UncheckedExtrinsic, Extrinsic, Call, Concrete, Staking,
-		BuildExternalities, GenesisConfig, SessionConfig, StakingConfig};
+		BuildExternalities, GenesisConfig, SessionConfig, StakingConfig, BareExtrinsic};
 	use ed25519::{Public, Pair};
 
 	const BLOATY_CODE: &[u8] = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.wasm");
@@ -63,24 +64,28 @@ mod tests {
 		)
 	}
 
-	fn alice() -> Hash {
-		Keyring::Alice.to_raw_public().into()
+	fn alice() -> AccountId {
+		AccountId::from(Keyring::Alice.to_raw_public())
 	}
 
-	fn bob() -> Hash {
-		Keyring::Bob.to_raw_public().into()
+	fn bob() -> AccountId {
+		AccountId::from(Keyring::Bob.to_raw_public())
 	}
 
 	fn xt() -> UncheckedExtrinsic {
-		let extrinsic = Extrinsic {
+		let extrinsic = BareExtrinsic {
 			signed: alice(),
 			index: 0,
-			function: Call::Staking(staking::Call::transfer::<Concrete>(bob(), 69)),
+			function: Call::Staking(staking::Call::transfer::<Concrete>(bob().into(), 69)),
 		};
-		let signature = Keyring::from_raw_public(extrinsic.signed.0).unwrap()
-			.sign(&extrinsic.encode()).into();
-
-		UncheckedExtrinsic { extrinsic, signature }
+		let signature = MaybeUnsigned(Keyring::from_raw_public(extrinsic.signed.0.clone()).unwrap()
+			.sign(&extrinsic.encode()).into());
+		let extrinsic = Extrinsic {
+			signed: extrinsic.signed.into(),
+			index: extrinsic.index,
+			function: extrinsic.function,
+		};
+		UncheckedExtrinsic::new(extrinsic, signature)
 	}
 
 	fn from_block_number(n: u64) -> Header {
@@ -93,28 +98,36 @@ mod tests {
 			twox_128(&<staking::FreeBalance<Concrete>>::key_for(alice())).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
 			twox_128(<staking::TransactionBaseFee<Concrete>>::key()).to_vec() => vec![70u8; 8],
 			twox_128(<staking::TransactionByteFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::ExistentialDeposit<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::TransferFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::NextEnumSet<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(&<system::BlockHash<Concrete>>::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
 		let r = Executor::new().call(&mut t, BLOATY_CODE, "initialise_block", &vec![].and(&from_block_number(1u64)));
 		assert!(r.is_ok());
-		let r = Executor::new().call(&mut t, BLOATY_CODE, "apply_extrinsic", &vec![].and(&xt()));
-		assert!(r.is_err());
+		let v = Executor::new().call(&mut t, BLOATY_CODE, "apply_extrinsic", &vec![].and(&xt())).unwrap();
+		let r = ApplyResult::decode(&mut &v[..]).unwrap();
+		assert_eq!(r, Err(ApplyError::CantPay));
 	}
 
 	#[test]
-	fn panic_execution_with_native_equivalent_code_gives_error() {
+	fn bad_extrinsic_with_native_equivalent_code_gives_error() {
 		let mut t: TestExternalities = map![
 			twox_128(&<staking::FreeBalance<Concrete>>::key_for(alice())).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
 			twox_128(<staking::TransactionBaseFee<Concrete>>::key()).to_vec() => vec![70u8; 8],
 			twox_128(<staking::TransactionByteFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::ExistentialDeposit<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::TransferFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::NextEnumSet<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(&<system::BlockHash<Concrete>>::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
 		let r = Executor::new().call(&mut t, COMPACT_CODE, "initialise_block", &vec![].and(&from_block_number(1u64)));
 		assert!(r.is_ok());
-		let r = Executor::new().call(&mut t, COMPACT_CODE, "apply_extrinsic", &vec![].and(&xt()));
-		assert!(r.is_err());
+		let v = Executor::new().call(&mut t, COMPACT_CODE, "apply_extrinsic", &vec![].and(&xt())).unwrap();
+		let r = ApplyResult::decode(&mut &v[..]).unwrap();
+		assert_eq!(r, Err(ApplyError::CantPay));
 	}
 
 	#[test]
@@ -123,6 +136,9 @@ mod tests {
 			twox_128(&<staking::FreeBalance<Concrete>>::key_for(alice())).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
 			twox_128(<staking::TransactionBaseFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(<staking::TransactionByteFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::ExistentialDeposit<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::TransferFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::NextEnumSet<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(&<system::BlockHash<Concrete>>::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
@@ -132,8 +148,8 @@ mod tests {
 		assert!(r.is_ok());
 
 		runtime_io::with_externalities(&mut t, || {
-			assert_eq!(Staking::balance(&alice()), 42);
-			assert_eq!(Staking::balance(&bob()), 69);
+			assert_eq!(Staking::voting_balance(&alice()), 42);
+			assert_eq!(Staking::voting_balance(&bob()), 69);
 		});
 	}
 
@@ -143,6 +159,9 @@ mod tests {
 			twox_128(&<staking::FreeBalance<Concrete>>::key_for(alice())).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
 			twox_128(<staking::TransactionBaseFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(<staking::TransactionByteFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::ExistentialDeposit<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::TransferFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::NextEnumSet<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(&<system::BlockHash<Concrete>>::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
@@ -152,8 +171,8 @@ mod tests {
 		assert!(r.is_ok());
 
 		runtime_io::with_externalities(&mut t, || {
-			assert_eq!(Staking::balance(&alice()), 42);
-			assert_eq!(Staking::balance(&bob()), 69);
+			assert_eq!(Staking::voting_balance(&alice()), 42);
+			assert_eq!(Staking::voting_balance(&bob()), 69);
 		});
 	}
 
@@ -176,20 +195,29 @@ mod tests {
 				bonding_duration: 0,
 				transaction_base_fee: 1,
 				transaction_byte_fee: 0,
+				existential_deposit: 0,
+				transfer_fee: 0,
+				creation_fee: 0,
+				contract_fee: 0,
+				reclaim_rebate: 0,
 			}),
 			democracy: Some(Default::default()),
 			council: Some(Default::default()),
 		}.build_externalities()
 	}
 
-	fn construct_block(number: BlockNumber, parent_hash: Hash, state_root: Hash, extrinsics: Vec<Extrinsic>) -> (Vec<u8>, Hash) {
+	fn construct_block(number: BlockNumber, parent_hash: Hash, state_root: Hash, extrinsics: Vec<BareExtrinsic>) -> (Vec<u8>, Hash) {
 		use triehash::ordered_trie_root;
 
 		let extrinsics = extrinsics.into_iter().map(|extrinsic| {
-			let signature = Pair::from(Keyring::from_public(Public::from_raw(extrinsic.signed.0)).unwrap())
-				.sign(&extrinsic.encode()).into();
-
-			UncheckedExtrinsic { extrinsic, signature }
+			let signature = MaybeUnsigned(Pair::from(Keyring::from_public(Public::from_raw(extrinsic.signed.0.clone())).unwrap())
+				.sign(&extrinsic.encode()).into());
+			let extrinsic = Extrinsic {
+				signed: extrinsic.signed.into(),
+				index: extrinsic.index,
+				function: extrinsic.function,
+			};
+			UncheckedExtrinsic::new(extrinsic, signature)
 		}).collect::<Vec<_>>();
 
 		let extrinsics_root = ordered_trie_root(extrinsics.iter().map(Slicable::encode)).0.into();
@@ -210,11 +238,11 @@ mod tests {
 		construct_block(
 			1,
 			[69u8; 32].into(),
-			hex!("76b0393b4958d3cb98bb51d9f4edb316af48485142b8721e94c3b52c75ec3243").into(),
-			vec![Extrinsic {
+			hex!("4f7a61bceecddc19d49fbee53f82402c2a8727c1b2aeb5e5070a59f0777a203b").into(),
+			vec![BareExtrinsic {
 				signed: alice(),
 				index: 0,
-				function: Call::Staking(staking::Call::transfer(bob(), 69)),
+				function: Call::Staking(staking::Call::transfer(bob().into(), 69)),
 			}]
 		)
 	}
@@ -223,17 +251,17 @@ mod tests {
 		construct_block(
 			2,
 			block1().1,
-			hex!("8ae9828a5988459d35fb428086170dead660176ee0766e89bc1a4b48153d4e88").into(),
+			hex!("67c588603dd727601263cf8d6138a2003ffc0df793c5ea34e7defc945da24bf0").into(),
 			vec![
-				Extrinsic {
+				BareExtrinsic {
 					signed: bob(),
 					index: 0,
-					function: Call::Staking(staking::Call::transfer(alice(), 5)),
+					function: Call::Staking(staking::Call::transfer(alice().into(), 5)),
 				},
-				Extrinsic {
+				BareExtrinsic {
 					signed: alice(),
 					index: 1,
-					function: Call::Staking(staking::Call::transfer(bob(), 15)),
+					function: Call::Staking(staking::Call::transfer(bob().into(), 15)),
 				}
 			]
 		)
@@ -246,15 +274,15 @@ mod tests {
 		Executor::new().call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap();
 
 		runtime_io::with_externalities(&mut t, || {
-			assert_eq!(Staking::balance(&alice()), 41);
-			assert_eq!(Staking::balance(&bob()), 69);
+			assert_eq!(Staking::voting_balance(&alice()), 41);
+			assert_eq!(Staking::voting_balance(&bob()), 69);
 		});
 
 		Executor::new().call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap();
 
 		runtime_io::with_externalities(&mut t, || {
-			assert_eq!(Staking::balance(&alice()), 30);
-			assert_eq!(Staking::balance(&bob()), 78);
+			assert_eq!(Staking::voting_balance(&alice()), 30);
+			assert_eq!(Staking::voting_balance(&bob()), 78);
 		});
 	}
 
@@ -265,15 +293,15 @@ mod tests {
 		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap();
 
 		runtime_io::with_externalities(&mut t, || {
-			assert_eq!(Staking::balance(&alice()), 41);
-			assert_eq!(Staking::balance(&bob()), 69);
+			assert_eq!(Staking::voting_balance(&alice()), 41);
+			assert_eq!(Staking::voting_balance(&bob()), 69);
 		});
 
 		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap();
 
 		runtime_io::with_externalities(&mut t, || {
-			assert_eq!(Staking::balance(&alice()), 30);
-			assert_eq!(Staking::balance(&bob()), 78);
+			assert_eq!(Staking::voting_balance(&alice()), 30);
+			assert_eq!(Staking::voting_balance(&bob()), 78);
 		});
 	}
 
@@ -283,14 +311,18 @@ mod tests {
 			twox_128(&<staking::FreeBalance<Concrete>>::key_for(alice())).to_vec() => vec![69u8, 0, 0, 0, 0, 0, 0, 0],
 			twox_128(<staking::TransactionBaseFee<Concrete>>::key()).to_vec() => vec![70u8; 8],
 			twox_128(<staking::TransactionByteFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::ExistentialDeposit<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::TransferFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::NextEnumSet<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(&<system::BlockHash<Concrete>>::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
 		let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.wasm");
 		let r = WasmExecutor.call(&mut t, &foreign_code[..], "initialise_block", &vec![].and(&from_block_number(1u64)));
 		assert!(r.is_ok());
-		let r = WasmExecutor.call(&mut t, &foreign_code[..], "apply_extrinsic", &vec![].and(&xt()));
-		assert!(r.is_err());
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "apply_extrinsic", &vec![].and(&xt())).unwrap();
+		let r = ApplyResult::decode(&mut &r[..]).unwrap();
+		assert_eq!(r, Err(ApplyError::CantPay));
 	}
 
 	#[test]
@@ -299,18 +331,22 @@ mod tests {
 			twox_128(&<staking::FreeBalance<Concrete>>::key_for(alice())).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
 			twox_128(<staking::TransactionBaseFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(<staking::TransactionByteFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::ExistentialDeposit<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::TransferFee<Concrete>>::key()).to_vec() => vec![0u8; 8],
+			twox_128(<staking::NextEnumSet<Concrete>>::key()).to_vec() => vec![0u8; 8],
 			twox_128(&<system::BlockHash<Concrete>>::key_for(0)).to_vec() => vec![0u8; 32]
 		];
 
 		let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.compact.wasm");
 		let r = WasmExecutor.call(&mut t, &foreign_code[..], "initialise_block", &vec![].and(&from_block_number(1u64)));
 		assert!(r.is_ok());
-		let r = WasmExecutor.call(&mut t, &foreign_code[..], "apply_extrinsic", &vec![].and(&xt()));
-		assert!(r.is_ok());
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "apply_extrinsic", &vec![].and(&xt())).unwrap();
+		let r = ApplyResult::decode(&mut &r[..]).unwrap();
+		assert_eq!(r, Ok(ApplyOutcome::Success));
 
 		runtime_io::with_externalities(&mut t, || {
-			assert_eq!(Staking::balance(&alice()), 42);
-			assert_eq!(Staking::balance(&bob()), 69);
+			assert_eq!(Staking::voting_balance(&alice()), 42);
+			assert_eq!(Staking::voting_balance(&bob()), 69);
 		});
 	}
 }

demo/primitives/src/lib.rs

@@ -35,6 +35,10 @@ pub type BlockNumber = u64;
 /// certainly continue to be the same as the substrate's `AuthorityId`.
 pub type AccountId = ::primitives::H256;
 
+/// The type for looking up accounts. We don't expect more than 4 billion of them, but you
+/// never know...
+pub type AccountIndex = u32;
+
 /// Balance of an account.
 pub type Balance = u64;
 
@@ -49,4 +53,4 @@ pub type Index = u64;
 pub type Hash = primitives::H256;
 
 /// Alias to 512-bit hash when used in the context of a signature on the relay chain.
-pub type Signature = runtime_primitives::Ed25519Signature;
+pub type Signature = runtime_primitives::MaybeUnsigned<runtime_primitives::Ed25519Signature>;