refactor: change some types from U256 to U64

core/api/src/adapter.rs

@@ -207,7 +207,7 @@ where
             exec_ctx,
         )?;
         let gas_limit = gas_limit
-            .map(|gas| gas.as_u64())
+            .map(|gas| gas.low_u64())
             .unwrap_or(MAX_BLOCK_GAS_LIMIT);
 
         Ok(AxonExecutor.call(&backend, gas_limit, from, to, value, data))

core/api/src/jsonrpc/error.rs

@@ -1,6 +1,6 @@
 use jsonrpsee::types::{error::ErrorObject, ErrorObjectOwned};
 
-use protocol::types::{ExitReason, TxResp};
+use protocol::types::{ExitReason, TxResp, U256};
 use protocol::{codec::hex_encode, Display};
 
 use core_executor::decode_revert_msg;
@@ -42,7 +42,7 @@ pub enum RpcError {
     #[display(fmt = "Invalid newest block {:?}", _0)]
     InvalidNewestBlock(BlockId),
     #[display(fmt = "Invalid position {}", _0)]
-    InvalidPosition(u64),
+    InvalidPosition(U256),
     #[display(fmt = "Cannot find the block")]
     CannotFindBlock,
     #[display(fmt = "Invalid reward percentiles {} {}", _0, _1)]

core/api/src/jsonrpc/impl/axon.rs

@@ -7,7 +7,7 @@ use common_config_parser::types::spec::HardforkName;
 use protocol::async_trait;
 use protocol::traits::{APIAdapter, Context};
 use protocol::types::{
-    Block, CkbRelatedInfo, HardforkInfoInner, Metadata, Proof, Proposal, H256, U256,
+    Block, CkbRelatedInfo, HardforkInfoInner, Metadata, Proof, Proposal, H256, U64,
 };
 
 use crate::jsonrpc::web3_types::{BlockId, HardforkStatus};
@@ -28,9 +28,15 @@ impl<Adapter: APIAdapter + 'static> AxonRpcServer for AxonRpcImpl<Adapter> {
     async fn get_block_by_id(&self, block_id: BlockId) -> RpcResult<Option<Block>> {
         let ret = match block_id {
             BlockId::Hash(hash) => self.adapter.get_block_by_hash(Context::new(), hash).await,
+            // The block number is checked when deserialize
             BlockId::Num(num) => {
                 self.adapter
-                    .get_block_by_number(Context::new(), Some(num.as_u64()))
+                    .get_block_by_number(Context::new(), Some(num.low_u64()))
+                    .await
+            }
+            BlockId::Earliest => {
+                self.adapter
+                    .get_block_by_number(Context::new(), Some(0))
                     .await
             }
             BlockId::Latest => self.adapter.get_block_by_number(Context::new(), None).await,
@@ -49,17 +55,17 @@ impl<Adapter: APIAdapter + 'static> AxonRpcServer for AxonRpcImpl<Adapter> {
         Ok(ret)
     }
 
-    async fn get_metadata_by_number(&self, block_number: U256) -> RpcResult<Metadata> {
+    async fn get_metadata_by_number(&self, block_number: U64) -> RpcResult<Metadata> {
         let ret = self
             .adapter
-            .get_metadata_by_number(Context::new(), Some(block_number.as_u64()))
+            .get_metadata_by_number(Context::new(), Some(block_number.low_u64()))
             .await
             .map_err(|e| RpcError::Internal(e.to_string()))?;
 
         Ok(ret)
     }
 
-    async fn get_proposal_by_number(&self, block_number: U256) -> RpcResult<Proposal> {
+    async fn get_proposal_by_number(&self, block_number: U64) -> RpcResult<Proposal> {
         let block_number = block_number.low_u64();
 
         let prev_state_root = if block_number == 0 {

core/api/src/jsonrpc/impl/filter.rs

@@ -204,7 +204,7 @@ where
 
                 match from {
                     BlockId::Num(n) => {
-                        if n.as_u64() < header.number {
+                        if n.low_u64() < header.number {
                             filter.from_block = Some(BlockId::Num(U64::from(header.number + 1)));
                         }
                     }
@@ -302,7 +302,7 @@ where
         let (start, end) = {
             let convert = |id: &BlockId| -> BlockNumber {
                 match id {
-                    BlockId::Num(n) => n.as_u64(),
+                    BlockId::Num(n) => n.low_u64(),
                     BlockId::Earliest => 0,
                     _ => latest_number,
                 }

core/api/src/jsonrpc/impl/web3.rs

@@ -7,17 +7,16 @@ use protocol::traits::{APIAdapter, Context};
 use protocol::types::{
     Block, BlockNumber, Bytes, EthAccountProof, Hash, Header, Hex, Proposal, Receipt,
     SignedTransaction, TxResp, UnverifiedTransaction, BASE_FEE_PER_GAS, H160, H256,
-    MAX_FEE_HISTORY, MAX_RPC_GAS_CAP, MIN_TRANSACTION_GAS_LIMIT, U256,
+    MAX_FEE_HISTORY, MAX_RPC_GAS_CAP, MIN_TRANSACTION_GAS_LIMIT, U256, U64,
 };
 use protocol::{
     async_trait, codec::ProtocolCodec, lazy::PROTOCOL_VERSION, tokio::time::sleep, ProtocolResult,
     MEMPOOL_REFRESH_TIMEOUT,
 };
 
 use crate::jsonrpc::web3_types::{
-    BlockCount, BlockId, FeeHistoryEmpty, FeeHistoryWithReward, FeeHistoryWithoutReward,
-    RichTransactionOrHash, Web3Block, Web3CallRequest, Web3FeeHistory, Web3Filter, Web3Log,
-    Web3Receipt, Web3Transaction,
+    BlockId, FeeHistoryEmpty, FeeHistoryWithReward, FeeHistoryWithoutReward, RichTransactionOrHash,
+    Web3Block, Web3CallRequest, Web3FeeHistory, Web3Filter, Web3Log, Web3Receipt, Web3Transaction,
 };
 use crate::jsonrpc::{error::RpcError, Web3RpcServer};
 use crate::APIError;
@@ -130,7 +129,7 @@ impl<Adapter: APIAdapter> Web3RpcImpl<Adapter> {
     async fn inner_fee_history(
         &self,
         height: Option<u64>,
-        block_count: U256,
+        block_count: u64,
         reward_percentiles: &Option<Vec<f64>>,
     ) -> Result<(u64, Vec<U256>, Vec<f64>, Vec<Vec<U256>>), RpcError> {
         let latest_block = self
@@ -142,7 +141,7 @@ impl<Adapter: APIAdapter> Web3RpcImpl<Adapter> {
 
         let latest_block_number = latest_block.header.number;
         let oldest_block_number = latest_block_number
-            .saturating_sub(block_count.as_u64())
+            .saturating_sub(block_count)
             .saturating_add(1);
 
         let mut bash_fee_per_gases: Vec<U256> = Vec::new();
@@ -209,6 +208,7 @@ impl<Adapter: APIAdapter + 'static> Web3RpcServer for Web3RpcImpl<Adapter> {
             return Err(RpcError::GasLimitIsTooLow.into());
         }
 
+        // The max_gas_cap must be le u64::MAX
         if gas_limit > self.max_gas_cap {
             return Err(RpcError::GasLimitIsTooLarge.into());
         }
@@ -454,7 +454,7 @@ impl<Adapter: APIAdapter + 'static> Web3RpcServer for Web3RpcImpl<Adapter> {
         }
 
         let num = match number {
-            Some(BlockId::Num(n)) => Some(n.as_u64()),
+            Some(BlockId::Num(n)) => Some(n.low_u64()),
             _ => None,
         };
         let data_bytes = req
@@ -673,7 +673,7 @@ impl<Adapter: APIAdapter + 'static> Web3RpcServer for Web3RpcImpl<Adapter> {
                 let (start, end) = {
                     let convert = |id: BlockId| -> BlockNumber {
                         match id {
-                            BlockId::Num(n) => n.as_u64(),
+                            BlockId::Num(n) => n.low_u64(),
                             BlockId::Earliest => 0,
                             _ => latest_number,
                         }
@@ -741,31 +741,29 @@ impl<Adapter: APIAdapter + 'static> Web3RpcServer for Web3RpcImpl<Adapter> {
     #[metrics_rpc("eth_feeHistory")]
     async fn fee_history(
         &self,
-        block_count: BlockCount,
+        block_count: U64,
         newest_block: BlockId,
         reward_percentiles: Option<Vec<f64>>,
     ) -> RpcResult<Web3FeeHistory> {
         check_reward_percentiles(&reward_percentiles)?;
 
-        let mut blocks_count;
-        match block_count {
-            BlockCount::U256Type(n) => blocks_count = n,
-            BlockCount::U64Type(n) => blocks_count = n.into(),
-        }
+        let mut blocks_count = block_count.low_u64();
         // Between 1 and 1024 blocks can be requested in a single query.
-        if blocks_count > MAX_FEE_HISTORY.into() {
-            blocks_count = MAX_FEE_HISTORY.into();
+        if blocks_count > MAX_FEE_HISTORY {
+            blocks_count = MAX_FEE_HISTORY;
         }
-        if blocks_count == 0.into() {
+
+        if blocks_count == 0 {
             return Ok(Web3FeeHistory::ZeroBlockCount(FeeHistoryEmpty {
                 oldest_block:   U256::zero(),
                 gas_used_ratio: None,
             }));
         }
+
         match newest_block {
             BlockId::Num(number) => {
                 let (oldest_block_number, bash_fee_per_gases, gas_used_ratios, reward) = self
-                    .inner_fee_history(number.as_u64().into(), blocks_count, &reward_percentiles)
+                    .inner_fee_history(number.low_u64().into(), blocks_count, &reward_percentiles)
                     .await?;
 
                 match reward_percentiles {
@@ -891,7 +889,7 @@ impl<Adapter: APIAdapter + 'static> Web3RpcServer for Web3RpcImpl<Adapter> {
         position: U256,
     ) -> RpcResult<Option<Web3Transaction>> {
         if position > U256::from(usize::MAX) {
-            return Err(RpcError::InvalidPosition(position.as_u64()).into());
+            return Err(RpcError::InvalidPosition(position).into());
         }
 
         let mut raw = [0u8; 32];
@@ -922,7 +920,7 @@ impl<Adapter: APIAdapter + 'static> Web3RpcServer for Web3RpcImpl<Adapter> {
         position: U256,
     ) -> RpcResult<Option<Web3Transaction>> {
         if position > U256::from(usize::MAX) {
-            return Err(RpcError::InvalidPosition(position.as_u64()).into());
+            return Err(RpcError::InvalidPosition(position).into());
         }
 
         let mut raw = [0u8; 32];
@@ -1047,7 +1045,8 @@ fn check_reward_percentiles(reward_percentiles: &Option<Vec<f64>>) -> RpcResult<
 fn calculate_gas_used_ratio(block: &Block) -> f64 {
     (block.header.gas_limit != U256::zero())
         .then(|| {
-            block.header.gas_used.as_u64() as f64 / block.header.gas_limit.as_u64() as f64 * 100f64
+            block.header.gas_used.low_u64() as f64 / block.header.gas_limit.low_u64() as f64
+                * 100f64
         })
         .unwrap_or(0f64)
 }

core/api/src/jsonrpc/mod.rs

@@ -15,13 +15,13 @@ use common_config_parser::types::{spec::HardforkName, Config};
 use protocol::traits::APIAdapter;
 use protocol::types::{
     Block, CkbRelatedInfo, EthAccountProof, Hash, Hex, Metadata, Proof, Proposal, H160, H256, U256,
+    U64,
 };
 use protocol::ProtocolResult;
 
 use crate::jsonrpc::web3_types::{
-    BlockCount, BlockId, FilterChanges, HardforkStatus, RawLoggerFilter, Web3Block,
-    Web3CallRequest, Web3FeeHistory, Web3Filter, Web3Log, Web3Receipt, Web3SyncStatus,
-    Web3Transaction,
+    BlockId, FilterChanges, HardforkStatus, RawLoggerFilter, Web3Block, Web3CallRequest,
+    Web3FeeHistory, Web3Filter, Web3Log, Web3Receipt, Web3SyncStatus, Web3Transaction,
 };
 use crate::jsonrpc::ws_subscription::{ws_subscription_module, HexIdProvider};
 use crate::APIError;
@@ -88,7 +88,7 @@ pub trait Web3Rpc {
     #[method(name = "eth_feeHistory")]
     async fn fee_history(
         &self,
-        block_count: BlockCount,
+        block_count: U64,
         newest_block: BlockId,
         reward_percentiles: Option<Vec<f64>>,
     ) -> RpcResult<Web3FeeHistory>;
@@ -222,10 +222,10 @@ pub trait AxonRpc {
     async fn get_proof_by_id(&self, block_id: BlockId) -> RpcResult<Option<Proof>>;
 
     #[method(name = "axon_getMetadataByNumber")]
-    async fn get_metadata_by_number(&self, block_number: U256) -> RpcResult<Metadata>;
+    async fn get_metadata_by_number(&self, block_number: U64) -> RpcResult<Metadata>;
 
     #[method(name = "axon_getProposalByNumber")]
-    async fn get_proposal_by_number(&self, block_number: U256) -> RpcResult<Proposal>;
+    async fn get_proposal_by_number(&self, block_number: U64) -> RpcResult<Proposal>;
 
     #[method(name = "axon_getCurrentMetadata")]
     async fn get_current_metadata(&self) -> RpcResult<Metadata>;

core/api/src/jsonrpc/web3_types.rs

@@ -334,7 +334,8 @@ pub enum BlockId {
 impl From<BlockId> for Option<u64> {
     fn from(id: BlockId) -> Self {
         match id {
-            BlockId::Num(num) => Some(num.as_u64()),
+            // The BlockId deserialize visitor will ensure that the number is in u64 range.
+            BlockId::Num(num) => Some(num.low_u64()),
             BlockId::Earliest => Some(0),
             _ => None,
         }
@@ -690,13 +691,6 @@ pub struct SyncStatus {
     pub pulled_states:  U256,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-#[serde(deny_unknown_fields, rename_all = "camelCase", untagged)]
-pub enum BlockCount {
-    U64Type(u64),
-    U256Type(U256),
-}
-
 /// Response type for `eth_feeHistory` RPC call.
 /// Three types of response are possible:
 /// 1. With reward, it returned when request parameter REWARDPERCENTILES is not

core/consensus/src/engine.rs

@@ -729,7 +729,7 @@ impl<Adapter: ConsensusAdapter + 'static> ConsensusEngine<Adapter> {
             ctx,
             resp.state_root,
             MAX_BLOCK_GAS_LIMIT,
-            last_status.max_tx_size.as_u64(),
+            last_status.max_tx_size.low_u64(),
         );
 
         if block.header.number != proof.number {

core/executor/benches/revm_adapter.rs

@@ -52,7 +52,7 @@ where
         let raw = raw.unwrap();
         Ok(Some(Account::decode(raw).map(|a| AccountInfo {
             balance:   U256(a.balance.0),
-            nonce:     a.nonce.as_u64(),
+            nonce:     a.nonce.low_u64(),
             code_hash: a.code_hash,
             code:      None,
         })?))
@@ -101,11 +101,11 @@ where
 
     fn block_hash(&mut self, number: U256) -> Result<H256, Self::Error> {
         let current_number = self.exec_ctx.block_number;
-        if number.as_u64() > current_number.as_u64() {
+        if number > current_number {
             return Ok(H256::default());
         }
 
-        let number = number.as_u64();
+        let number = number.low_u64();
         let res = blocking_async!(self, storage, get_block, Context::new(), number)
             .map(|b| b.hash())
             .unwrap_or_default();
@@ -299,7 +299,7 @@ where
             .nonce;
         set_revm(
             evm,
-            tx.transaction.unsigned.gas_limit().as_u64(),
+            tx.transaction.unsigned.gas_limit().low_u64(),
             Some(tx.sender),
             tx.transaction.unsigned.to(),
             *tx.transaction.unsigned.value(),
@@ -324,7 +324,7 @@ where
             exit_reason: evm::ExitReason::Succeed(ExitSucceed::Returned),
             ret,
             gas_used: res.gas_used,
-            remain_gas: tx.transaction.unsigned.gas_limit().as_u64() - res.gas_used,
+            remain_gas: tx.transaction.unsigned.gas_limit().low_u64() - res.gas_used,
             fee_cost: res.gas_used.into(),
             // todo
             logs: vec![],

core/executor/src/adapter/backend/read_only.rs

@@ -77,7 +77,7 @@ where
             return H256::default();
         }
 
-        let number = number.as_u64();
+        let number = number.low_u64();
         blocking_async!(self, get_storage, get_block, Context::new(), number)
             .map(|b| b.hash())
             .unwrap_or_default()

core/executor/src/debugger/create2.rs

@@ -29,7 +29,7 @@ async fn test_create2_gas() {
     let gas_used = resp.tx_resp[0].gas_used;
     let after_balance = debugger.backend(1).basic(sender).balance;
 
-    assert_eq!(gas_used * 8, (init_balance - after_balance).as_u64());
+    assert_eq!(gas_used * 8, (init_balance - after_balance).low_u64());
 }
 
 fn mock_create2_tx(nonce: U256, sender: H160) -> SignedTransaction {

core/executor/src/lib.rs

@@ -312,7 +312,7 @@ impl AxonExecutor {
         account.balance = account.balance.saturating_sub(prepay_gas);
         adapter.save_account(&sender, &account);
 
-        let metadata = StackSubstateMetadata::new(gas_limit.as_u64(), config);
+        let metadata = StackSubstateMetadata::new(gas_limit.low_u64(), config);
         let mut executor = StackExecutor::new_with_precompiles(
             MemoryStackState::new(metadata, adapter),
             config,
@@ -333,14 +333,14 @@ impl AxonExecutor {
                 *addr,
                 *tx.transaction.unsigned.value(),
                 tx.transaction.unsigned.data().to_vec(),
-                gas_limit.as_u64(),
+                gas_limit.low_u64(),
                 access_list,
             ),
             TransactionAction::Create => executor.transact_create(
                 tx.sender,
                 *tx.transaction.unsigned.value(),
                 tx.transaction.unsigned.data().to_vec(),
-                gas_limit.as_u64(),
+                gas_limit.low_u64(),
                 access_list,
             ),
         };