Use Either

Author: perekopskiy

Cargo.lock

@@ -72,6 +72,7 @@ metrics = "=0.13.0-alpha.8"
 lru-cache = "0.1.2"
 once_cell = "1.4"
 regex = "1"
+either = "1.6.1"
 
 [dev-dependencies]
 zksync_test_account = { path = "../../tests/test_account" }

core/bin/zksync_api/Cargo.toml

@@ -11,8 +11,7 @@ use actix_web::{web, Scope};
 use zksync_api_types::v02::{
     account::{Account, AccountAddressOrId, AccountStateType},
     pagination::{
-        parse_query, AccountTxsRequestWithLatest, IdOrLatest, Paginated, PaginationQuery,
-        PendingOpsRequest,
+        parse_query, AccountTxsRequest, ApiEither, Paginated, PaginationQuery, PendingOpsRequest,
     },
     transaction::{Transaction, TxHashSerializeWrapper},
 };
@@ -169,12 +168,12 @@ impl ApiAccountData {
 
     async fn account_txs(
         &self,
-        query: PaginationQuery<IdOrLatest<TxHash>>,
+        query: PaginationQuery<ApiEither<TxHash>>,
         address: Address,
     ) -> Result<Paginated<Transaction, TxHashSerializeWrapper>, Error> {
         let mut storage = self.pool.access_storage().await.map_err(Error::storage)?;
         let new_query = PaginationQuery {
-            from: AccountTxsRequestWithLatest {
+            from: AccountTxsRequest {
                 address,
                 tx_hash: query.from,
             },
@@ -190,7 +189,7 @@ impl ApiAccountData {
     /// but we can still find pending deposits for its address that is why account_id is Option.
     async fn account_pending_txs(
         &self,
-        query: PaginationQuery<IdOrLatest<SerialId>>,
+        query: PaginationQuery<ApiEither<SerialId>>,
         address: Address,
         account_id: Option<AccountId>,
     ) -> Result<Paginated<Transaction, SerialId>, Error> {
@@ -243,9 +242,7 @@ async fn account_txs(
     web::Path(account_id_or_address): web::Path<String>,
     web::Query(query): web::Query<PaginationQuery<String>>,
 ) -> ApiResult<Paginated<Transaction, TxHashSerializeWrapper>> {
-    let query =
-        api_try!(parse_query(query)
-            .ok_or_else(|| Error::from(InvalidDataError::QueryDeserializationError)));
+    let query = api_try!(parse_query(query).map_err(Error::from));
     let address_or_id = api_try!(data.parse_account_id_or_address(&account_id_or_address));
     let address = api_try!(data.get_address_by_address_or_id(address_or_id).await);
     data.account_txs(query, address).await.into()
@@ -256,9 +253,7 @@ async fn account_pending_txs(
     web::Path(account_id_or_address): web::Path<String>,
     web::Query(query): web::Query<PaginationQuery<String>>,
 ) -> ApiResult<Paginated<Transaction, SerialId>> {
-    let query =
-        api_try!(parse_query(query)
-            .ok_or_else(|| Error::from(InvalidDataError::QueryDeserializationError)));
+    let query = api_try!(parse_query(query).map_err(Error::from));
     let address_or_id = api_try!(data.parse_account_id_or_address(&account_id_or_address));
     let address = api_try!(
         data.get_address_by_address_or_id(address_or_id.clone())
@@ -438,7 +433,7 @@ mod tests {
                 from: PendingOpsRequest {
                     address: Address::default(),
                     account_id: Some(AccountId::default()),
-                    serial_id: IdOrLatest::Id(0),
+                    serial_id: ApiEither::from(0),
                 },
                 limit: 0,
                 direction: PaginationDirection::Newer,
@@ -477,7 +472,7 @@ mod tests {
         assert_eq!(account_info_by_id, account_info_by_address);
 
         let query = PaginationQuery {
-            from: IdOrLatest::Id(tx_hash),
+            from: ApiEither::from(tx_hash),
             limit: 1,
             direction: PaginationDirection::Newer,
         };
@@ -515,7 +510,7 @@ mod tests {
         });
 
         let query = PaginationQuery {
-            from: IdOrLatest::Id(1),
+            from: ApiEither::from(1),
             limit: 1,
             direction: PaginationDirection::Newer,
         };

core/bin/zksync_api/src/api_server/rest/v02/account.rs

@@ -9,7 +9,7 @@ use actix_web::{web, Scope};
 // Workspace uses
 use zksync_api_types::v02::{
     block::{BlockInfo, BlockStatus},
-    pagination::{parse_query, BlockAndTxHashOrLatest, IdOrLatest, Paginated, PaginationQuery},
+    pagination::{parse_query, ApiEither, BlockAndTxHash, Paginated, PaginationQuery},
     transaction::{Transaction, TxHashSerializeWrapper},
 };
 use zksync_crypto::{convert::FeConvert, Fr};
@@ -25,7 +25,7 @@ use super::{
 use crate::{api_try, utils::block_details_cache::BlockDetailsCache};
 
 pub fn block_info_from_details(details: StorageBlockDetails) -> BlockInfo {
-    let status = if details.verified_at.is_some() {
+    let status = if details.is_verified() {
         BlockStatus::Finalized
     } else {
         BlockStatus::Committed
@@ -101,7 +101,7 @@ impl ApiBlockData {
 
     async fn block_page(
         &self,
-        query: PaginationQuery<IdOrLatest<BlockNumber>>,
+        query: PaginationQuery<ApiEither<BlockNumber>>,
     ) -> Result<Paginated<BlockInfo, BlockNumber>, Error> {
         let mut storage = self.pool.access_storage().await.map_err(Error::storage)?;
         storage.paginate_checked(&query).await
@@ -110,12 +110,12 @@ impl ApiBlockData {
     async fn transaction_page(
         &self,
         block_number: BlockNumber,
-        query: PaginationQuery<IdOrLatest<TxHash>>,
+        query: PaginationQuery<ApiEither<TxHash>>,
     ) -> Result<Paginated<Transaction, TxHashSerializeWrapper>, Error> {
         let mut storage = self.pool.access_storage().await.map_err(Error::storage)?;
 
         let new_query = PaginationQuery {
-            from: BlockAndTxHashOrLatest {
+            from: BlockAndTxHash {
                 block_number,
                 tx_hash: query.from,
             },
@@ -151,9 +151,7 @@ async fn block_pagination(
     data: web::Data<ApiBlockData>,
     web::Query(query): web::Query<PaginationQuery<String>>,
 ) -> ApiResult<Paginated<BlockInfo, BlockNumber>> {
-    let query =
-        api_try!(parse_query(query)
-            .ok_or_else(|| Error::from(InvalidDataError::QueryDeserializationError)));
+    let query = api_try!(parse_query(query).map_err(Error::from));
     data.block_page(query).await.into()
 }
 
@@ -174,9 +172,7 @@ async fn block_transactions(
     web::Query(query): web::Query<PaginationQuery<String>>,
 ) -> ApiResult<Paginated<Transaction, TxHashSerializeWrapper>> {
     let block_number = api_try!(data.get_block_number_by_position(&block_position).await);
-    let query =
-        api_try!(parse_query(query)
-            .ok_or_else(|| Error::from(InvalidDataError::QueryDeserializationError)));
+    let query = api_try!(parse_query(query).map_err(Error::from));
 
     data.transaction_page(block_number, query).await.into()
 }
@@ -224,7 +220,7 @@ mod tests {
         );
 
         let query = PaginationQuery {
-            from: IdOrLatest::Id(BlockNumber(1)),
+            from: ApiEither::from(BlockNumber(1)),
             limit: 3,
             direction: PaginationDirection::Newer,
         };
@@ -258,7 +254,7 @@ mod tests {
         let tx_hash = TxHash::from_str(tx_hash_str).unwrap();
 
         let query = PaginationQuery {
-            from: IdOrLatest::Id(tx_hash),
+            from: ApiEither::from(tx_hash),
             limit: 2,
             direction: PaginationDirection::Older,
         };

core/bin/zksync_api/src/api_server/rest/v02/block.rs

@@ -7,7 +7,7 @@ use serde_repr::Serialize_repr;
 use thiserror::Error;
 
 // Workspace uses
-use zksync_api_types::v02::pagination::MAX_LIMIT;
+use zksync_api_types::v02::pagination::{UnknownFromParamater, MAX_LIMIT};
 
 // Local uses
 use crate::{api_server::tx_sender::SubmitError, fee_ticker::PriceError};
@@ -96,10 +96,8 @@ pub enum InvalidDataError {
     InvalidCurrency,
     #[error("Transaction is not found")]
     TransactionNotFound,
-    #[error("Limit for pagination should be less or equal than {}", MAX_LIMIT)]
+    #[error("Limit for pagination should be less than or equal to {}", MAX_LIMIT)]
     PaginationLimitTooBig,
-    #[error("Cannot parse query parameters")]
-    QueryDeserializationError,
 }
 
 impl ApiError for InvalidDataError {
@@ -116,7 +114,6 @@ impl ApiError for InvalidDataError {
             Self::InvalidCurrency => ErrorCode::InvalidCurrency,
             Self::TransactionNotFound => ErrorCode::TransactionNotFound,
             Self::PaginationLimitTooBig => ErrorCode::PaginationLimitTooBig,
-            Self::QueryDeserializationError => ErrorCode::QueryDeserializationError,
         }
     }
 }
@@ -204,3 +201,13 @@ impl ApiError for PriceError {
         }
     }
 }
+
+impl ApiError for UnknownFromParamater {
+    fn error_type(&self) -> String {
+        String::from("invalidDataError")
+    }
+
+    fn code(&self) -> ErrorCode {
+        ErrorCode::QueryDeserializationError
+    }
+}