blockchain.rs

			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
		}.sign(&secret(), None);
		let t2 = Transaction {
			nonce: 0.into(),
			gas_price: 0.into(),
			gas: 100_000.into(),
			action: Action::Create,
			value: 102.into(),
			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
		}.sign(&secret(), None);
		let t3 = Transaction {
			nonce: 0.into(),
			gas_price: 0.into(),
			gas: 100_000.into(),
			action: Action::Create,
			value: 103.into(),
			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
		}.sign(&secret(), None);
		let t4 = Transaction {
			nonce: 0.into(),
			gas_price: 0.into(),
			gas: 100_000.into(),
			action: Action::Create,
			value: 104.into(),
			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
		}.sign(&secret(), None);
		let tx_hash1 = t1.hash();
		let tx_hash2 = t2.hash();
		let tx_hash3 = t3.hash();
		let tx_hash4 = t4.hash();

		let genesis = BlockBuilder::genesis();
		let b1 = genesis.add_block_with_transactions(vec![t1, t2]);
		let b2 = b1.add_block_with_transactions(iter::once(t3));
		let b3 = genesis.add_block_with(|| BlockOptions {
			transactions: vec![t4.clone()],
			difficulty: U256::from(9),
			..Default::default()
		}); // Branch block
		let b1_hash = b1.last().hash();
		let b1_number = b1.last().number();
		let b2_hash = b2.last().hash();
		let b2_number = b2.last().number();
		let b3_hash = b3.last().hash();
		let b3_number = b3.last().number();

		let db = new_db();
		let bc = new_chain(&genesis.last().encoded(), db.clone());
		insert_block(&db, &bc, &b1.last().encoded(), vec![Receipt {
			outcome: TransactionOutcome::StateRoot(H256::default()),
			gas_used: 10_000.into(),
			log_bloom: Default::default(),
			logs: vec![
				LogEntry { address: Default::default(), topics: vec![], data: vec![1], },
				LogEntry { address: Default::default(), topics: vec![], data: vec![2], },
			],
		},
		Receipt {
			outcome: TransactionOutcome::StateRoot(H256::default()),
			gas_used: 10_000.into(),
			log_bloom: Default::default(),
			logs: vec![
				LogEntry { address: Default::default(), topics: vec![], data: vec![3], },
			],
		}]);
		insert_block(&db, &bc, &b2.last().encoded(), vec![
			Receipt {
				outcome: TransactionOutcome::StateRoot(H256::default()),
				gas_used: 10_000.into(),
				log_bloom: Default::default(),
				logs: vec![
					LogEntry { address: Default::default(), topics: vec![], data: vec![4], },
				],
			}
		]);
		insert_block(&db, &bc, &b3.last().encoded(), vec![
			Receipt {
				outcome: TransactionOutcome::StateRoot(H256::default()),
				gas_used: 10_000.into(),
				log_bloom: Default::default(),
				logs: vec![
					LogEntry { address: Default::default(), topics: vec![], data: vec![5], },
				],
			}
		]);

		// when
		let logs1 = bc.logs(vec![b1_hash, b2_hash], |_| true, None);
		let logs2 = bc.logs(vec![b1_hash, b2_hash], |_| true, Some(1));
		let logs3 = bc.logs(vec![b3_hash], |_| true, None);

		// then
		assert_eq!(logs1, vec![
			LocalizedLogEntry {
				entry: LogEntry { address: Default::default(), topics: vec![], data: vec![1] },
				block_hash: b1_hash,
				block_number: b1_number,
				transaction_hash: tx_hash1,
				transaction_index: 0,
				transaction_log_index: 0,
				log_index: 0,
			},
			LocalizedLogEntry {
				entry: LogEntry { address: Default::default(), topics: vec![], data: vec![2] },
				block_hash: b1_hash,
				block_number: b1_number,
				transaction_hash: tx_hash1,
				transaction_index: 0,
				transaction_log_index: 1,
				log_index: 1,
			},
			LocalizedLogEntry {
				entry: LogEntry { address: Default::default(), topics: vec![], data: vec![3] },
				block_hash: b1_hash,
				block_number: b1_number,
				transaction_hash: tx_hash2,
				transaction_index: 1,
				transaction_log_index: 0,
				log_index: 2,
			},
			LocalizedLogEntry {
				entry: LogEntry { address: Default::default(), topics: vec![], data: vec![4] },
				block_hash: b2_hash,
				block_number: b2_number,
				transaction_hash: tx_hash3,
				transaction_index: 0,
				transaction_log_index: 0,
				log_index: 0,
			}
		]);
		assert_eq!(logs2, vec![
			LocalizedLogEntry {
				entry: LogEntry { address: Default::default(), topics: vec![], data: vec![4] },
				block_hash: b2_hash,
				block_number: b2_number,
				transaction_hash: tx_hash3,
				transaction_index: 0,
				transaction_log_index: 0,
				log_index: 0,
			}
		]);
		assert_eq!(logs3, vec![
			LocalizedLogEntry {
				entry: LogEntry { address: Default::default(), topics: vec![], data: vec![5] },
				block_hash: b3_hash,
				block_number: b3_number,
				transaction_hash: tx_hash4,
				transaction_index: 0,
				transaction_log_index: 0,
				log_index: 0,
			}
		]);
	}

	#[test]
	fn test_bloom_filter_simple() {
		let bloom_b1: Bloom = "00000020000000000000000000000000000000000000000002000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000400000000000000000000002000".into();

		let bloom_b2: Bloom = "00000000000000000000000000000000000000000000020000001000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();

		let bloom_ba: Bloom = "00000000000000000000000000000000000000000000020000000800000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();

		let genesis = BlockBuilder::genesis();
		let b1 = genesis.add_block_with(|| BlockOptions {
			bloom: bloom_b1.clone(),
			difficulty: 9.into(),
			..Default::default()
		});
		let b2 = b1.add_block_with_bloom(bloom_b2);
		let b3 = b2.add_block_with_bloom(bloom_ba);

		let b1a = genesis.add_block_with_bloom(bloom_ba);
		let b2a = b1a.add_block_with_bloom(bloom_ba);

		let db = new_db();
		let bc = new_chain(&genesis.last().encoded(), db.clone());

		let blocks_b1 = bc.blocks_with_bloom(Some(&bloom_b1), 0, 5);
		let blocks_b2 = bc.blocks_with_bloom(Some(&bloom_b2), 0, 5);
		assert!(blocks_b1.is_empty());
		assert!(blocks_b2.is_empty());

		insert_block(&db, &bc, &b1.last().encoded(), vec![]);
		let blocks_b1 = bc.blocks_with_bloom(Some(&bloom_b1), 0, 5);
		let blocks_b2 = bc.blocks_with_bloom(Some(&bloom_b2), 0, 5);
		assert_eq!(blocks_b1, vec![1]);
		assert!(blocks_b2.is_empty());

		insert_block(&db, &bc, &b2.last().encoded(), vec![]);
		let blocks_b1 = bc.blocks_with_bloom(Some(&bloom_b1), 0, 5);
		let blocks_b2 = bc.blocks_with_bloom(Some(&bloom_b2), 0, 5);
		assert_eq!(blocks_b1, vec![1]);
		assert_eq!(blocks_b2, vec![2]);

		// hasn't been forked yet
		insert_block(&db, &bc, &b1a.last().encoded(), vec![]);
		let blocks_b1 = bc.blocks_with_bloom(Some(&bloom_b1), 0, 5);
		let blocks_b2 = bc.blocks_with_bloom(Some(&bloom_b2), 0, 5);
		let blocks_ba = bc.blocks_with_bloom(Some(&bloom_ba), 0, 5);
		assert_eq!(blocks_b1, vec![1]);
		assert_eq!(blocks_b2, vec![2]);
		assert!(blocks_ba.is_empty());

		// fork has happend
		insert_block(&db, &bc, &b2a.last().encoded(), vec![]);
		let blocks_b1 = bc.blocks_with_bloom(Some(&bloom_b1), 0, 5);
		let blocks_b2 = bc.blocks_with_bloom(Some(&bloom_b2), 0, 5);
		let blocks_ba = bc.blocks_with_bloom(Some(&bloom_ba), 0, 5);
		assert!(blocks_b1.is_empty());
		assert!(blocks_b2.is_empty());
		assert_eq!(blocks_ba, vec![1, 2]);

		// fork back
		insert_block(&db, &bc, &b3.last().encoded(), vec![]);
		let blocks_b1 = bc.blocks_with_bloom(Some(&bloom_b1), 0, 5);
		let blocks_b2 = bc.blocks_with_bloom(Some(&bloom_b2), 0, 5);
		let blocks_ba = bc.blocks_with_bloom(Some(&bloom_ba), 0, 5);
		assert_eq!(blocks_b1, vec![1]);
		assert_eq!(blocks_b2, vec![2]);
		assert_eq!(blocks_ba, vec![3]);
	}

	#[test]
	fn test_insert_unordered() {
		let bloom_b1: Bloom = "00000020000000000000000000000000000000000000000002000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000400000000000000000000002000".into();

		let bloom_b2: Bloom = "00000000000000000000000000000000000000000000020000001000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();

		let bloom_b3: Bloom = "00000000000000000000000000000000000000000000020000000800000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();

		let genesis = BlockBuilder::genesis();
		let b1 = genesis.add_block_with_bloom(bloom_b1);
		let b2 = b1.add_block_with_bloom(bloom_b2);
		let b3 = b2.add_block_with_bloom(bloom_b3);
		let b1_total_difficulty = genesis.last().difficulty() + b1.last().difficulty();

		let db = new_db();
		let bc = new_chain(&genesis.last().encoded(), db.clone());
		let mut batch = db.key_value().transaction();
		bc.insert_unordered_block(&mut batch, &b2.last().encoded(), vec![], Some(b1_total_difficulty), false, false);
		bc.commit();
		bc.insert_unordered_block(&mut batch, &b3.last().encoded(), vec![], None, true, false);
		bc.commit();
		bc.insert_unordered_block(&mut batch, &b1.last().encoded(), vec![], None, false, false);
		bc.commit();
		db.key_value().write(batch).unwrap();

		assert_eq!(bc.best_block_hash(), b3.last().hash());
		assert_eq!(bc.block_hash(1).unwrap(), b1.last().hash());
		assert_eq!(bc.block_hash(2).unwrap(), b2.last().hash());
		assert_eq!(bc.block_hash(3).unwrap(), b3.last().hash());

		let blocks_b1 = bc.blocks_with_bloom(Some(&bloom_b1), 0, 3);
		let blocks_b2 = bc.blocks_with_bloom(Some(&bloom_b2), 0, 3);
		let blocks_b3 = bc.blocks_with_bloom(Some(&bloom_b3), 0, 3);

		assert_eq!(blocks_b1, vec![1]);
		assert_eq!(blocks_b2, vec![2]);
		assert_eq!(blocks_b3, vec![3]);
	}

	#[test]
	fn test_best_block_update() {
		let genesis = BlockBuilder::genesis();
		let next_5 = genesis.add_blocks(5);
		let uncle = genesis.add_block_with_difficulty(9);
		let generator = BlockGenerator::new(iter::once(next_5));

		let db = new_db();
		{
			let bc = new_chain(&genesis.last().encoded(), db.clone());

			let mut batch = db.key_value().transaction();
			// create a longer fork
			for block in generator {
				insert_block_batch(&mut batch, &bc, &block.encoded(), vec![]);
				bc.commit();
			}

			assert_eq!(bc.best_block_number(), 5);
			insert_block_batch(&mut batch, &bc, &uncle.last().encoded(), vec![]);
			db.key_value().write(batch).unwrap();
			bc.commit();
		}

		// re-loading the blockchain should load the correct best block.
		let bc = new_chain(&genesis.last().encoded(), db);
		assert_eq!(bc.best_block_number(), 5);
	}

	#[test]
	fn epoch_transitions_iter() {
		use ::engines::EpochTransition;

		let genesis = BlockBuilder::genesis();
		let next_5 = genesis.add_blocks(5);
		let uncle = genesis.add_block_with_difficulty(9);
		let generator = BlockGenerator::new(iter::once(next_5));

		let db = new_db();
		{
			let bc = new_chain(&genesis.last().encoded(), db.clone());

			let mut batch = db.key_value().transaction();
			// create a longer fork
			for (i, block) in generator.into_iter().enumerate() {

				insert_block_batch(&mut batch, &bc, &block.encoded(), vec![]);
				bc.insert_epoch_transition(&mut batch, i as u64, EpochTransition {
					block_hash: block.hash(),
					block_number: i as u64 + 1,
					proof: vec![],
				});
				bc.commit();
			}

			assert_eq!(bc.best_block_number(), 5);

			insert_block_batch(&mut batch, &bc, &uncle.last().encoded(), vec![]);
			bc.insert_epoch_transition(&mut batch, 999, EpochTransition {
				block_hash: uncle.last().hash(),
				block_number: 1,
				proof: vec![],
			});

			db.key_value().write(batch).unwrap();
			bc.commit();

			// epoch 999 not in canonical chain.
			assert_eq!(bc.epoch_transitions().map(|(i, _)| i).collect::<Vec<_>>(), vec![0, 1, 2, 3, 4]);
		}

		// re-loading the blockchain should load the correct best block.
		let bc = new_chain(&genesis.last().encoded(), db);

		assert_eq!(bc.best_block_number(), 5);
		assert_eq!(bc.epoch_transitions().map(|(i, _)| i).collect::<Vec<_>>(), vec![0, 1, 2, 3, 4]);
	}

	#[test]
	fn epoch_transition_for() {
		use ::engines::EpochTransition;

		let genesis = BlockBuilder::genesis();
		let fork_7 = genesis.add_blocks_with(7, || BlockOptions {
			difficulty: 9.into(),
			..Default::default()
		});
		let next_10 = genesis.add_blocks(10);
		let fork_generator = BlockGenerator::new(iter::once(fork_7));
		let next_generator = BlockGenerator::new(iter::once(next_10));

		let db = new_db();

		let bc = new_chain(&genesis.last().encoded(), db.clone());

		let mut batch = db.key_value().transaction();
		bc.insert_epoch_transition(&mut batch, 0, EpochTransition {
			block_hash: bc.genesis_hash(),
			block_number: 0,
			proof: vec![],
		});
		db.key_value().write(batch).unwrap();

		// set up a chain where we have a canonical chain of 10 blocks
		// and a non-canonical fork of 8 from genesis.
		let fork_hash = {
			for block in fork_generator {
				insert_block(&db, &bc, &block.encoded(), vec![]);
			}

			assert_eq!(bc.best_block_number(), 7);
			bc.chain_info().best_block_hash
		};

		for block in next_generator {
			insert_block(&db, &bc, &block.encoded(), vec![]);
		}

		assert_eq!(bc.best_block_number(), 10);

		let mut batch = db.key_value().transaction();
		bc.insert_epoch_transition(&mut batch, 4, EpochTransition {
			block_hash: bc.block_hash(4).unwrap(),
			block_number: 4,
			proof: vec![],
		});
		db.key_value().write(batch).unwrap();

		// blocks where the parent is one of the first 4 will be part of genesis epoch.
		for i in 0..4 {
			let hash = bc.block_hash(i).unwrap();
			assert_eq!(bc.epoch_transition_for(hash).unwrap().block_number, 0);
		}

		// blocks where the parent is the transition at 4 or after will be
		// part of that epoch.
		for i in 4..11 {
			let hash = bc.block_hash(i).unwrap();
			assert_eq!(bc.epoch_transition_for(hash).unwrap().block_number, 4);
		}

		let fork_hashes = bc.ancestry_iter(fork_hash).unwrap().collect::<Vec<_>>();
		assert_eq!(fork_hashes.len(), 8);

		// non-canonical fork blocks should all have genesis transition
		for fork_hash in fork_hashes {
			assert_eq!(bc.epoch_transition_for(fork_hash).unwrap().block_number, 0);
		}
	}
}