Rename oldest_receipt_number to oldest_unconfirmed_receipt_number

NingLin-P · NingLin-P · commit b3aa3b199dfa · 2024-01-24T17:02:57.000+08:00
Signed-off-by: linning &lt;linningde25@gmail.com&gt;
diff --git a/crates/pallet-domains/src/benchmarking.rs b/crates/pallet-domains/src/benchmarking.rs
@@ -87,7 +87,7 @@ mod benchmarks {
             (block_tree_pruning_depth + 1).into()
         );
         assert_eq!(
-            Domains::<T>::oldest_receipt_number(domain_id),
+            Domains::<T>::oldest_unconfirmed_receipt_number(domain_id),
             Some(1u32.into())
         );
     }
diff --git a/crates/pallet-domains/src/lib.rs b/crates/pallet-domains/src/lib.rs
@@ -1860,9 +1860,11 @@ impl<T: Config> Pallet<T> {
         HeadReceiptNumber::<T>::get(domain_id)
     }
 
-    /// Returns the block number of oldest existing execution receipt, return `None` means there is
-    /// no non-confirmed ER exist or submitted yet.
-    pub fn oldest_receipt_number(domain_id: DomainId) -> Option<DomainBlockNumberFor<T>> {
+    /// Returns the block number of the oldest existing unconfirmed execution receipt, return `None`
+    /// means there is no unconfirmed ER exist or submitted yet.
+    pub fn oldest_unconfirmed_receipt_number(
+        domain_id: DomainId,
+    ) -> Option<DomainBlockNumberFor<T>> {
         let oldest_nonconfirmed_er_number =
             LatestConfirmedDomainBlockNumber::<T>::get(domain_id).saturating_add(One::one());
 
diff --git a/crates/sp-domains/src/lib.rs b/crates/sp-domains/src/lib.rs
@@ -994,8 +994,8 @@ sp_api::decl_runtime_apis! {
         /// Returns the best execution chain number.
         fn head_receipt_number(domain_id: DomainId) -> HeaderNumberFor<DomainHeader>;
 
-        /// Returns the block number of oldest execution receipt.
-        fn oldest_receipt_number(domain_id: DomainId) -> Option<HeaderNumberFor<DomainHeader>>;
+        /// Returns the block number of oldest unconfirmed execution receipt.
+        fn oldest_unconfirmed_receipt_number(domain_id: DomainId) -> Option<HeaderNumberFor<DomainHeader>>;
 
         /// Returns the domain block limit of the given domain.
         fn domain_block_limit(domain_id: DomainId) -> Option<DomainBlockLimit>;
diff --git a/crates/subspace-runtime/src/lib.rs b/crates/subspace-runtime/src/lib.rs
@@ -1032,8 +1032,8 @@ impl_runtime_apis! {
             Domains::head_receipt_number(domain_id)
         }
 
-        fn oldest_receipt_number(domain_id: DomainId) -> Option<DomainNumber> {
-            Domains::oldest_receipt_number(domain_id)
+        fn oldest_unconfirmed_receipt_number(domain_id: DomainId) -> Option<DomainNumber> {
+            Domains::oldest_unconfirmed_receipt_number(domain_id)
         }
 
         fn domain_block_limit(domain_id: DomainId) -> Option<sp_domains::DomainBlockLimit> {
diff --git a/domains/client/domain-operator/src/aux_schema.rs b/domains/client/domain-operator/src/aux_schema.rs
@@ -64,7 +64,7 @@ fn load_decode<Backend: AuxStore, T: Decode>(
 /// too old.
 pub(super) fn write_execution_receipt<Backend, Block, CBlock>(
     backend: &Backend,
-    oldest_receipt_number: Option<NumberFor<Block>>,
+    oldest_unconfirmed_receipt_number: Option<NumberFor<Block>>,
     execution_receipt: &ExecutionReceiptFor<Block, CBlock>,
 ) -> Result<(), sp_blockchain::Error>
 where
@@ -90,8 +90,10 @@ where
     let mut keys_to_delete = vec![];
 
     // Delete ER that have comfirned long time ago, also see the comment of `PRUNING_DEPTH`
-    if let Some(delete_receipts_to) = oldest_receipt_number
-        .map(|oldest_receipt_number| oldest_receipt_number.saturating_sub(One::one()))
+    if let Some(delete_receipts_to) = oldest_unconfirmed_receipt_number
+        .map(|oldest_unconfirmed_receipt_number| {
+            oldest_unconfirmed_receipt_number.saturating_sub(One::one())
+        })
         .and_then(|latest_confirmed_receipt_number| {
             latest_confirmed_receipt_number
                 .saturated_into::<BlockNumber>()
@@ -309,10 +311,14 @@ mod tests {
             load_execution_receipt::<_, Block, CBlock>(&client, consensus_block_hash).unwrap()
         };
 
-        let write_receipt_at = |oldest_receipt_number: Option<BlockNumber>,
+        let write_receipt_at = |oldest_unconfirmed_receipt_number: Option<BlockNumber>,
                                 receipt: &ExecutionReceipt| {
-            write_execution_receipt::<_, Block, CBlock>(&client, oldest_receipt_number, receipt)
-                .unwrap()
+            write_execution_receipt::<_, Block, CBlock>(
+                &client,
+                oldest_unconfirmed_receipt_number,
+                receipt,
+            )
+            .unwrap()
         };
 
         assert_eq!(receipt_start(), None);
@@ -323,10 +329,10 @@ mod tests {
             .map(|block_number| {
                 let receipt = create_execution_receipt(block_number);
                 let consensus_block_hash = receipt.consensus_block_hash;
-                let oldest_receipt_number = block_number
+                let oldest_unconfirmed_receipt_number = block_number
                     .checked_sub(block_tree_pruning_depth)
                     .map(|n| n + 1);
-                write_receipt_at(oldest_receipt_number, &receipt);
+                write_receipt_at(oldest_unconfirmed_receipt_number, &receipt);
                 assert_eq!(receipt_at(consensus_block_hash), Some(receipt));
                 assert_eq!(hashes_at(block_number), Some(vec![consensus_block_hash]));
                 // No ER have been pruned yet
@@ -338,14 +344,14 @@ mod tests {
         assert_eq!(receipt_start(), Some(0));
         assert!(!target_receipt_is_pruned(1));
 
-        // Create `receipt_count + 1` receipt, `oldest_receipt_number` is `PRUNING_DEPTH + 1`.
+        // Create `receipt_count + 1` receipt, `oldest_unconfirmed_receipt_number` is `PRUNING_DEPTH + 1`.
         let receipt = create_execution_receipt(receipt_count + 1);
         assert!(receipt_at(receipt.consensus_block_hash).is_none());
         write_receipt_at(Some(PRUNING_DEPTH + 1), &receipt);
         assert!(receipt_at(receipt.consensus_block_hash).is_some());
         assert_eq!(receipt_start(), Some(1));
 
-        // Create `receipt_count + 2` receipt, `oldest_receipt_number` is `PRUNING_DEPTH + 2`.
+        // Create `receipt_count + 2` receipt, `oldest_unconfirmed_receipt_number` is `PRUNING_DEPTH + 2`.
         let receipt = create_execution_receipt(receipt_count + 2);
         write_receipt_at(Some(PRUNING_DEPTH + 2), &receipt);
         assert!(receipt_at(receipt.consensus_block_hash).is_some());
@@ -356,7 +362,7 @@ mod tests {
         assert!(target_receipt_is_pruned(1));
         assert_eq!(receipt_start(), Some(2));
 
-        // Create `receipt_count + 3` receipt, `oldest_receipt_number` is `PRUNING_DEPTH + 3`.
+        // Create `receipt_count + 3` receipt, `oldest_unconfirmed_receipt_number` is `PRUNING_DEPTH + 3`.
         let receipt = create_execution_receipt(receipt_count + 3);
         let consensus_block_hash1 = receipt.consensus_block_hash;
         write_receipt_at(Some(PRUNING_DEPTH + 3), &receipt);
@@ -376,13 +382,13 @@ mod tests {
             hashes_at(receipt_count + 3),
             Some(vec![consensus_block_hash1, consensus_block_hash2])
         );
-        // No ER pruned since the `oldest_receipt_number` is the same
+        // No ER pruned since the `oldest_unconfirmed_receipt_number` is the same
         assert!(!target_receipt_is_pruned(3));
         assert_eq!(receipt_start(), Some(3));
     }
 
     #[test]
-    fn execution_receipts_should_be_kept_against_oldest_receipt_number() {
+    fn execution_receipts_should_be_kept_against_oldest_unconfirmed_receipt_number() {
         let block_tree_pruning_depth = 256;
         let client = TestClient::default();
 
@@ -403,17 +409,21 @@ mod tests {
             load_execution_receipt::<_, Block, CBlock>(&client, consensus_block_hash).unwrap()
         };
 
-        let write_receipt_at = |oldest_receipt_number: Option<BlockNumber>,
+        let write_receipt_at = |oldest_unconfirmed_receipt_number: Option<BlockNumber>,
                                 receipt: &ExecutionReceipt| {
-            write_execution_receipt::<_, Block, CBlock>(&client, oldest_receipt_number, receipt)
-                .unwrap()
+            write_execution_receipt::<_, Block, CBlock>(
+                &client,
+                oldest_unconfirmed_receipt_number,
+                receipt,
+            )
+            .unwrap()
         };
 
         let target_receipt_is_pruned = |number: BlockNumber| hashes_at(number).is_none();
 
         assert_eq!(receipt_start(), None);
 
-        // Create as many ER as before any ER being pruned yet, `oldest_receipt_number` is `Some(1)`,
+        // Create as many ER as before any ER being pruned yet, `oldest_unconfirmed_receipt_number` is `Some(1)`,
         // i.e., no receipt has ever been confirmed/pruned on consensus chain.
         let receipt_count = PRUNING_DEPTH + block_tree_pruning_depth - 1;
 
@@ -433,12 +443,12 @@ mod tests {
         assert_eq!(receipt_start(), Some(0));
         assert!(!target_receipt_is_pruned(1));
 
-        // Create `receipt_count + 1` receipt, `oldest_receipt_number` is `Some(1)`.
+        // Create `receipt_count + 1` receipt, `oldest_unconfirmed_receipt_number` is `Some(1)`.
         let receipt = create_execution_receipt(receipt_count + 1);
         assert!(receipt_at(receipt.consensus_block_hash).is_none());
         write_receipt_at(Some(One::one()), &receipt);
 
-        // Create `receipt_count + 2` receipt, `oldest_receipt_number` is `Some(1)`.
+        // Create `receipt_count + 2` receipt, `oldest_unconfirmed_receipt_number` is `Some(1)`.
         let receipt = create_execution_receipt(receipt_count + 2);
         write_receipt_at(Some(One::one()), &receipt);
 
@@ -449,11 +459,11 @@ mod tests {
         assert!(!target_receipt_is_pruned(1));
         assert_eq!(receipt_start(), Some(0));
 
-        // Create `receipt_count + 3` receipt, `oldest_receipt_number` is `Some(1)`.
+        // Create `receipt_count + 3` receipt, `oldest_unconfirmed_receipt_number` is `Some(1)`.
         let receipt = create_execution_receipt(receipt_count + 3);
         write_receipt_at(Some(One::one()), &receipt);
 
-        // Create `receipt_count + 4` receipt, `oldest_receipt_number` is `Some(PRUNING_DEPTH + 4)`.
+        // Create `receipt_count + 4` receipt, `oldest_unconfirmed_receipt_number` is `Some(PRUNING_DEPTH + 4)`.
         let receipt = create_execution_receipt(receipt_count + 4);
         write_receipt_at(
             Some(PRUNING_DEPTH + 4), // Now assuming all the missing receipts are confirmed.
diff --git a/domains/client/domain-operator/src/domain_block_processor.rs b/domains/client/domain-operator/src/domain_block_processor.rs
@@ -517,13 +517,13 @@ where
                 header_number: _,
                 execution_receipt,
             }) => {
-                let oldest_receipt_number = self
+                let oldest_unconfirmed_receipt_number = self
                     .consensus_client
                     .runtime_api()
-                    .oldest_receipt_number(consensus_block_hash, self.domain_id)?;
+                    .oldest_unconfirmed_receipt_number(consensus_block_hash, self.domain_id)?;
                 crate::aux_schema::write_execution_receipt::<_, Block, CBlock>(
                     &*self.client,
-                    oldest_receipt_number,
+                    oldest_unconfirmed_receipt_number,
                     &execution_receipt,
                 )?;
 
@@ -762,17 +762,17 @@ where
             .consensus_client
             .runtime_api()
             .head_receipt_number(consensus_block_hash, self.domain_id)?;
-        let oldest_receipt_number = match self
+        let oldest_unconfirmed_receipt_number = match self
             .consensus_client
             .runtime_api()
-            .oldest_receipt_number(consensus_block_hash, self.domain_id)?
+            .oldest_unconfirmed_receipt_number(consensus_block_hash, self.domain_id)?
         {
             Some(er_number) => er_number,
             // Early return if there is no non-confirmed ER exist
             None => return Ok(None),
         };
 
-        while !to_check.is_zero() && oldest_receipt_number <= to_check {
+        while !to_check.is_zero() && oldest_unconfirmed_receipt_number <= to_check {
             let onchain_receipt_hash = self
                 .consensus_client
                 .runtime_api()
diff --git a/domains/client/relayer/src/worker.rs b/domains/client/relayer/src/worker.rs
@@ -118,7 +118,7 @@ pub async fn relay_domain_messages<CCC, DC, CCBlock, Block, SO>(
             let api = consensus_chain_client.runtime_api();
             let at = consensus_chain_client.info().best_hash;
             Ok(api
-                .oldest_receipt_number(at, domain_id)?
+                .oldest_unconfirmed_receipt_number(at, domain_id)?
                 // ensure block number is at least the oldest tracked number
                 .map(|oldest_tracked_number| block_number >= oldest_tracked_number)
                 .unwrap_or(false))
diff --git a/test/subspace-test-runtime/src/lib.rs b/test/subspace-test-runtime/src/lib.rs
@@ -1217,8 +1217,8 @@ impl_runtime_apis! {
             Domains::head_receipt_number(domain_id)
         }
 
-        fn oldest_receipt_number(domain_id: DomainId) -> Option<DomainNumber> {
-            Domains::oldest_receipt_number(domain_id)
+        fn oldest_unconfirmed_receipt_number(domain_id: DomainId) -> Option<DomainNumber> {
+            Domains::oldest_unconfirmed_receipt_number(domain_id)
         }
 
         fn domain_block_limit(domain_id: DomainId) -> Option<sp_domains::DomainBlockLimit> {

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ mod benchmarks {`
`87`	`87`	`(block_tree_pruning_depth + 1).into()`
`88`	`88`	`);`
`89`	`89`	`assert_eq!(`
`90`		`- Domains::<T>::oldest_receipt_number(domain_id),`
	`90`	`+ Domains::<T>::oldest_unconfirmed_receipt_number(domain_id),`
`91`	`91`	`Some(1u32.into())`
`92`	`92`	`);`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1032,8 +1032,8 @@ impl_runtime_apis! {`
`1032`	`1032`	`Domains::head_receipt_number(domain_id)`
`1033`	`1033`	`}`
`1034`	`1034`
`1035`		`- fn oldest_receipt_number(domain_id: DomainId) -> Option<DomainNumber> {`
`1036`		`- Domains::oldest_receipt_number(domain_id)`
	`1035`	`+ fn oldest_unconfirmed_receipt_number(domain_id: DomainId) -> Option<DomainNumber> {`
	`1036`	`+ Domains::oldest_unconfirmed_receipt_number(domain_id)`
`1037`	`1037`	`}`
`1038`	`1038`
`1039`	`1039`	`fn domain_block_limit(domain_id: DomainId) -> Option<sp_domains::DomainBlockLimit> {`
Original file line number	Diff line number	Diff line change
`@@ -1217,8 +1217,8 @@ impl_runtime_apis! {`
`1217`	`1217`	`Domains::head_receipt_number(domain_id)`
`1218`	`1218`	`}`
`1219`	`1219`
`1220`		`- fn oldest_receipt_number(domain_id: DomainId) -> Option<DomainNumber> {`
`1221`		`- Domains::oldest_receipt_number(domain_id)`
	`1220`	`+ fn oldest_unconfirmed_receipt_number(domain_id: DomainId) -> Option<DomainNumber> {`
	`1221`	`+ Domains::oldest_unconfirmed_receipt_number(domain_id)`
`1222`	`1222`	`}`
`1223`	`1223`
`1224`	`1224`	`fn domain_block_limit(domain_id: DomainId) -> Option<sp_domains::DomainBlockLimit> {`