[fix] #0000: HotFix for pagination not being reflected in the schema.

Signed-off-by: Aleksandr Petrosyan <[email protected]>

cli/src/torii/routing.rs

@@ -2,6 +2,8 @@
 //! Iroha you should add it here by creating a `handle_*` function,
 //! and add it to impl Torii. This module also defines the `VerifiedQueryRequest`,
 //! which is the only kind of query that is permitted to execute.
+use std::num::TryFromIntError;
+
 use eyre::WrapErr;
 use iroha_actor::Addr;
 use iroha_config::{Configurable, GetConfiguration, PostConfiguration};
@@ -95,7 +97,7 @@ pub(crate) async fn handle_instructions<W: WorldTrait>(
     #[allow(clippy::map_err_ignore)]
     let push_result = queue.push(transaction).map_err(|(_, err)| err);
     if let Err(ref error) = push_result {
-        iroha_logger::warn!(%error, "Failed to push to queue")
+        iroha_logger::warn!(%error, "Failed to push into queue")
     }
     push_result
         .map_err(Box::new)
@@ -109,17 +111,27 @@ pub(crate) async fn handle_queries<W: WorldTrait>(
     query_validator: Arc<IsQueryAllowedBoxed<W>>,
     pagination: Pagination,
     request: VerifiedQueryRequest,
-) -> Result<Scale<VersionedQueryResult>, warp::http::Response<warp::hyper::Body>> {
+) -> Result<Scale<VersionedPaginatedQueryResult>, warp::http::Response<warp::hyper::Body>> {
     let valid_request = request
         .validate(&wsv, &query_validator)
         .map_err(into_reply)?;
-    let result = valid_request.execute(&wsv).map_err(into_reply)?;
-    let result = QueryResult(if let Value::Vec(value) = result {
+    let original_result = valid_request.execute(&wsv).map_err(into_reply)?;
+    let total: u64 = original_result
+        .len()
+        .try_into()
+        .map_err(|e: TryFromIntError| QueryError::Conversion(e.to_string()))
+        .map_err(into_reply)?;
+    let result = QueryResult(if let Value::Vec(value) = original_result {
         Value::Vec(value.into_iter().paginate(pagination).collect())
     } else {
-        result
+        original_result
     });
-    Ok(Scale(result.into()))
+    let paginated_result = PaginatedQueryResult {
+        result,
+        pagination,
+        total,
+    };
+    Ok(Scale(paginated_result.into()))
 }
 
 #[allow(clippy::needless_pass_by_value)] // Required for `map_err`.

cli/src/torii/tests.rs

@@ -105,8 +105,11 @@ async fn torii_pagination() {
         )
         .map(|result| {
             let Scale(query_result) = result.unwrap();
-            if let VersionedQueryResult::V1(QueryResult(Value::Vec(domain))) = query_result {
-                domain
+            let VersionedPaginatedQueryResult::V1(PaginatedQueryResult { result, .. }) =
+                query_result;
+
+            if let QueryResult(Value::Vec(domains)) = result {
+                domains
             } else {
                 unreachable!()
             }

config/derive/src/lib.rs

@@ -22,7 +22,7 @@ mod attrs {
     pub const INNER: &str = "inner";
 }
 
-fn get_type_argument<'a, 'b>(s: &'a str, ty: &'b Type) -> Option<&'b GenericArgument> {
+fn get_type_argument<'sl, 'tl>(s: &'sl str, ty: &'tl Type) -> Option<&'tl GenericArgument> {
     let path = if let Type::Path(r#type) = ty {
         r#type
     } else {

config/src/lib.rs

@@ -172,9 +172,9 @@ pub trait Configurable: Serialize + DeserializeOwned {
     /// Gets inner field of arbitrary inner depth and returns as json-value
     /// # Errors
     /// Fails if field was unknown
-    fn get_recursive<'a, T>(&self, inner_field: T) -> Result<Value, Self::Error>
+    fn get_recursive<'tl, T>(&self, inner_field: T) -> Result<Value, Self::Error>
     where
-        T: AsRef<[&'a str]> + Send + 'a;
+        T: AsRef<[&'tl str]> + Send + 'tl;
 
     /// Fails if fails to deserialize from environment
     /// # Errors
@@ -184,8 +184,8 @@ pub trait Configurable: Serialize + DeserializeOwned {
     /// Gets docs of inner field of arbitrary depth
     /// # Errors
     /// Fails if field was unknown
-    fn get_doc_recursive<'a>(
-        field: impl AsRef<[&'a str]>,
+    fn get_doc_recursive<'tl>(
+        field: impl AsRef<[&'tl str]>,
     ) -> Result<Option<&'static str>, Self::Error>;
 
     /// Gets docs of field

config/src/runtime_upgrades.rs

@@ -30,7 +30,8 @@ pub enum ReloadError {
     Other,
 }
 
-type PoisonErr<'a, T> = PoisonError<MutexGuard<'a, Option<Box<(dyn ReloadMut<T> + Send + Sync)>>>>;
+type PoisonErr<'grd, T> =
+    PoisonError<MutexGuard<'grd, Option<Box<(dyn ReloadMut<T> + Send + Sync)>>>>;
 
 impl<T> From<PoisonErr<'_, T>> for ReloadError {
     fn from(_: PoisonErr<'_, T>) -> Self {

core/src/block.rs

@@ -96,14 +96,14 @@ impl Chain {
 }
 
 /// Chain iterator
-pub struct ChainIterator<'a> {
-    chain: &'a Chain,
+pub struct ChainIterator<'itm> {
+    chain: &'itm Chain,
     pos_front: u64,
     pos_back: u64,
 }
 
-impl<'a> ChainIterator<'a> {
-    fn new(chain: &'a Chain) -> Self {
+impl<'itm> ChainIterator<'itm> {
+    fn new(chain: &'itm Chain) -> Self {
         ChainIterator {
             chain,
             pos_front: 1,
@@ -116,8 +116,8 @@ impl<'a> ChainIterator<'a> {
     }
 }
 
-impl<'a> Iterator for ChainIterator<'a> {
-    type Item = MapRef<'a, u64, VersionedCommittedBlock>;
+impl<'itm> Iterator for ChainIterator<'itm> {
+    type Item = MapRef<'itm, u64, VersionedCommittedBlock>;
     fn next(&mut self) -> Option<Self::Item> {
         if !self.is_exhausted() {
             let val = self.chain.blocks.get(&self.pos_front);
@@ -150,7 +150,7 @@ impl<'a> Iterator for ChainIterator<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator for ChainIterator<'a> {
+impl<'itm> DoubleEndedIterator for ChainIterator<'itm> {
     fn next_back(&mut self) -> Option<Self::Item> {
         if !self.is_exhausted() {
             let val = self.chain.blocks.get(&self.pos_back);

core/src/smartcontracts/wasm.rs

@@ -68,7 +68,7 @@ impl From<ParseError> for Error {
     }
 }
 
-struct Validator<'a, W: WorldTrait> {
+struct Validator<'wrld, W: WorldTrait> {
     /// Number of instructions in the smartcontract
     instruction_count: u64,
     /// Max allowed number of instructions in the smartcontract
@@ -78,7 +78,7 @@ struct Validator<'a, W: WorldTrait> {
     /// If this particular query is allowed
     is_query_allowed: Arc<IsQueryAllowedBoxed<W>>,
     /// Current [`WorldStateview`]
-    wsv: &'a WorldStateView<W>,
+    wsv: &'wrld WorldStateView<W>,
 }
 
 impl<W: WorldTrait> Validator<'_, W> {
@@ -125,16 +125,16 @@ impl<W: WorldTrait> Validator<'_, W> {
     }
 }
 
-struct State<'a, W: WorldTrait> {
+struct State<'wrld, W: WorldTrait> {
     account_id: AccountId,
     /// Ensures smartcontract adheres to limits
-    validator: Option<Validator<'a, W>>,
+    validator: Option<Validator<'wrld, W>>,
     store_limits: StoreLimits,
-    wsv: &'a WorldStateView<W>,
+    wsv: &'wrld WorldStateView<W>,
 }
 
-impl<'a, W: WorldTrait> State<'a, W> {
-    fn new(wsv: &'a WorldStateView<W>, account_id: AccountId, config: Configuration) -> Self {
+impl<'wrld, W: WorldTrait> State<'wrld, W> {
+    fn new(wsv: &'wrld WorldStateView<W>, account_id: AccountId, config: Configuration) -> Self {
         Self {
             wsv,
             account_id,
@@ -171,13 +171,13 @@ impl<'a, W: WorldTrait> State<'a, W> {
 }
 
 /// `WebAssembly` virtual machine
-pub struct Runtime<'a, W: WorldTrait> {
+pub struct Runtime<'wrld, W: WorldTrait> {
     engine: Engine,
-    linker: Linker<State<'a, W>>,
+    linker: Linker<State<'wrld, W>>,
     config: Configuration,
 }
 
-impl<'a, W: WorldTrait> Runtime<'a, W> {
+impl<'wrld, W: WorldTrait> Runtime<'wrld, W> {
     /// `Runtime` constructor with default configuration.
     ///
     /// # Errors
@@ -344,7 +344,7 @@ impl<'a, W: WorldTrait> Runtime<'a, W> {
         Ok(())
     }
 
-    fn create_linker(engine: &Engine) -> Result<Linker<State<'a, W>>, Error> {
+    fn create_linker(engine: &Engine) -> Result<Linker<State<'wrld, W>>, Error> {
         let mut linker = Linker::new(engine);
 
         linker

core/src/sumeragi/message.rs

@@ -145,9 +145,9 @@ impl VersionedMessage {
     /// Send this message over the network to multiple `peers`.
     /// # Errors
     /// Fails if network sending fails
-    pub async fn send_to_multiple<'a, I>(self, broker: &Broker, peers: I)
+    pub async fn send_to_multiple<'itm, I>(self, broker: &Broker, peers: I)
     where
-        I: IntoIterator<Item = &'a PeerId> + Send,
+        I: IntoIterator<Item = &'itm PeerId> + Send,
     {
         let futures = peers
             .into_iter()

core/src/sumeragi/network_topology.rs

@@ -366,10 +366,10 @@ impl Topology {
     }
 
     /// Returns signatures of the peers with the specified `roles` from all `signatures`.
-    pub fn filter_signatures_by_roles<'a>(
-        &'a self,
-        roles: &'a [Role],
-        signatures: impl IntoIterator<Item = &'a SignatureOf<VersionedValidBlock>> + 'a,
+    pub fn filter_signatures_by_roles<'slf>(
+        &'slf self,
+        roles: &'slf [Role],
+        signatures: impl IntoIterator<Item = &'slf SignatureOf<VersionedValidBlock>> + 'slf,
     ) -> Vec<SignatureOf<VersionedValidBlock>> {
         let roles: HashSet<Role> = roles.iter().copied().collect();
         let public_keys: HashSet<_> = roles
@@ -484,8 +484,8 @@ mod tests {
     fn correct_number_of_peers_genesis() {
         let peers = topology_test_peers();
         // set_a.len() = 2, is wrong as it is not possible to get integer f in: 2f + 1 = 2
-        let set_a: HashSet<_> = topology_test_peers().iter().cloned().take(3).collect();
-        let set_b: HashSet<_> = topology_test_peers().iter().cloned().skip(3).collect();
+        let set_a: HashSet<_> = topology_test_peers().iter().take(3).cloned().collect();
+        let set_b: HashSet<_> = topology_test_peers().iter().skip(3).cloned().collect();
         let _network_topology = GenesisBuilder::new()
             .with_leader(peers.iter().next().unwrap().clone())
             .with_set_a(set_a)

core/src/triggers.rs

@@ -105,9 +105,9 @@ impl TriggerSet {
     ///
     /// Users should not try to modify [`TriggerSet`] before dropping actions,
     /// returned by the current function
-    pub fn find_matching<'e, E>(&self, events: E) -> Vec<Action>
+    pub fn find_matching<'evnt, E>(&self, events: E) -> Vec<Action>
     where
-        E: IntoIterator<Item = &'e Event>,
+        E: IntoIterator<Item = &'evnt Event>,
     {
         let mut result = Vec::new();
 

crypto/src/merkle.rs

@@ -61,8 +61,8 @@ pub enum Node<T> {
 
 #[derive(Debug)]
 /// BFS iterator over the Merkle tree
-pub struct BreadthFirstIter<'a, T> {
-    queue: Vec<&'a Node<T>>,
+pub struct BreadthFirstIter<'itm, T> {
+    queue: Vec<&'itm Node<T>>,
 }
 
 #[cfg(feature = "std")]
@@ -196,8 +196,8 @@ impl<T> Node<T> {
     }
 }
 
-impl<'a, T> BreadthFirstIter<'a, T> {
-    fn new(root_node: &'a Node<T>) -> Self {
+impl<'itm, T> BreadthFirstIter<'itm, T> {
+    fn new(root_node: &'itm Node<T>) -> Self {
         BreadthFirstIter {
             queue: vec![root_node],
         }
@@ -208,8 +208,8 @@ impl<'a, T> BreadthFirstIter<'a, T> {
 /// `'a` lifetime specified for `Node`. Because `Node` is recursive data structure with self
 /// composition in case of `Node::Subtree` we use `Box` to know size of each `Node` object in
 /// memory.
-impl<'a, T> Iterator for BreadthFirstIter<'a, T> {
-    type Item = &'a Node<T>;
+impl<'itm, T> Iterator for BreadthFirstIter<'itm, T> {
+    type Item = &'itm Node<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match &self.queue.pop() {
@@ -225,9 +225,9 @@ impl<'a, T> Iterator for BreadthFirstIter<'a, T> {
     }
 }
 
-impl<'a, T> IntoIterator for &'a MerkleTree<T> {
-    type Item = &'a Node<T>;
-    type IntoIter = BreadthFirstIter<'a, T>;
+impl<'itm, T> IntoIterator for &'itm MerkleTree<T> {
+    type Item = &'itm Node<T>;
+    type IntoIter = BreadthFirstIter<'itm, T>;
 
     fn into_iter(self) -> Self::IntoIter {
         BreadthFirstIter::new(&self.root_node)

crypto/src/signature.rs

@@ -348,9 +348,9 @@ impl<T> IntoIterator for SignaturesOf<T> {
     }
 }
 
-impl<'a, T> IntoIterator for &'a SignaturesOf<T> {
-    type Item = &'a SignatureOf<T>;
-    type IntoIter = btree_map::Values<'a, PublicKey, SignatureOf<T>>;
+impl<'itm, T> IntoIterator for &'itm SignaturesOf<T> {
+    type Item = &'itm SignatureOf<T>;
+    type IntoIter = btree_map::Values<'itm, PublicKey, SignatureOf<T>>;
     fn into_iter(self) -> Self::IntoIter {
         self.signatures.values()
     }
@@ -406,7 +406,7 @@ impl<T> SignaturesOf<T> {
     /// # Warning:
     ///
     /// This method uses [`core::mem::transmute`] internally
-    #[allow(unsafe_code)]
+    #[allow(unsafe_code, clippy::transmute_undefined_repr)]
     pub fn transmute<F>(self) -> SignaturesOf<F> {
         // SAFETY: Safe because we are transmuting to a pointer of
         // type `<F>` which is related to type `<T>`.

data_model/src/lib.rs

@@ -403,11 +403,11 @@ pub enum Value {
     LimitedMetadata(metadata::Metadata),
     /// `Id` of `Asset`, `Account`, etc.
     Id(IdBox),
-    /// `Identifiable` as `Asset`, `Account` etc.
+    /// `impl Identifiable` as in `Asset`, `Account` etc.
     Identifiable(IdentifiableBox),
     /// [`PublicKey`].
     PublicKey(PublicKey),
-    /// Iroha `Parameter` variant.
+    /// Iroha [`Parameter`] variant.
     Parameter(Parameter),
     /// Signature check condition.
     SignatureCheckCondition(SignatureCheckCondition),

data_model/src/pagination.rs

@@ -4,6 +4,7 @@
 #[cfg(not(feature = "std"))]
 use alloc::{
     collections::btree_map,
+    format,
     string::{String, ToString as _},
     vec,
     vec::Vec,
@@ -13,6 +14,7 @@ use core::fmt;
 use std::collections::btree_map;
 
 use iroha_schema::IntoSchema;
+use iroha_version::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "warp")]
 use warp::{
@@ -71,7 +73,9 @@ impl<I: Iterator> Iterator for Paginated<I> {
 }
 
 /// Structure for pagination requests
-#[derive(Clone, Eq, PartialEq, Debug, Default, Copy, Deserialize, Serialize, IntoSchema)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Default, Deserialize, Serialize, Decode, Encode, IntoSchema,
+)]
 pub struct Pagination {
     /// start of indexing
     pub start: Option<u32>,