Replicate the state root when constructing the trace merkle tree from the root list

Author: liuchengxu

Cargo.lock

@@ -105,8 +105,7 @@ pub(super) fn load_execution_receipt<Backend: AuxStore, Block: BlockT>(
 	backend: &Backend,
 	block_hash: Block::Hash,
 ) -> ClientResult<Option<ExecutionReceipt<Block::Hash>>> {
-	let key = (EXECUTION_RECEIPT_KEY, block_hash).encode();
-	load_decode(backend, key.as_slice())
+	load_decode(backend, execution_receipt_key(block_hash).as_slice())
 }
 
 pub(super) fn target_receipt_is_pruned<Block: BlockT>(

cumulus/client/cirrus-executor/src/aux_schema.rs

@@ -41,3 +41,26 @@ pub(super) type MerkleTree = merkletree::merkle::MerkleTree<
 	Sha256Algorithm,
 	merkletree::store::VecStore<Sha256Hash>,
 >;
+
+pub(super) fn construct_trace_merkle_tree(
+	roots: Vec<[u8; 32]>,
+) -> Result<MerkleTree, sp_blockchain::Error> {
+	let mut roots = roots;
+
+	let roots_len = roots.len();
+	assert!(roots_len >= 2, "Execution trace should at least contain 2 storage roots");
+
+	let ideal_len = merkletree::merkle::next_pow2(roots_len);
+
+	if ideal_len > roots_len {
+		// The last element of trace is state_root.
+		if let Some(state_root) = roots.last().copied() {
+			roots.resize(ideal_len, state_root);
+		}
+	}
+
+	MerkleTree::new(roots).map_err(|e| {
+		tracing::error!(target: crate::LOG_TARGET, error = ?e, "Failed to construct a trace Merkle tree");
+		sp_blockchain::Error::Application(e.into())
+	})
+}

cumulus/client/cirrus-executor/src/merkle_tree.rs

@@ -193,16 +193,21 @@ where
 
 		let mut roots =
 			self.client.runtime_api().intermediate_roots(&BlockId::Hash(parent_hash))?;
-		roots.push(
-			state_root.encode().try_into().expect(
-				"State root uses the same Block hash type which can fit into [u8; 32]; qed",
-			),
-		);
 
-		let trace_root = crate::merkle_tree::MerkleTree::new(roots.clone())
-			.map_err(|e| sp_blockchain::Error::Application(e.into()))?
-			.root();
+		if roots.is_empty() {
+			panic!(
+				"FIXME: runtime intermediate_roots is empty, uncovered by running the sync node!!!"
+			);
+		}
+
+		let state_root = state_root
+			.encode()
+			.try_into()
+			.expect("State root uses the same Block hash type which can fit into [u8; 32]; qed");
+
+		roots.push(state_root);
 
+		let trace_root = crate::merkle_tree::construct_trace_merkle_tree(roots.clone())?.root();
 		let trace = roots
 			.into_iter()
 			.map(|r| {
@@ -299,4 +304,17 @@ mod tests {
 
 		assert_eq!(shuffled_extrinsics, vec![100, 30, 10, 1, 11, 101, 31, 12, 102, 2]);
 	}
+
+	#[test]
+	fn construct_trace_merkle_tree_should_work() {
+		let root1 = [1u8; 32];
+		let root2 = [2u8; 32];
+		let root3 = [3u8; 32];
+
+		let roots = vec![root1, root2];
+		crate::merkle_tree::construct_trace_merkle_tree(roots).unwrap();
+
+		let roots = vec![root1, root2, root3];
+		crate::merkle_tree::construct_trace_merkle_tree(roots).unwrap();
+	}
 }