Feat tableinfo rpc

network-rpc/Cargo.toml

@@ -28,6 +28,7 @@ starcoin-txpool-api = { workspace = true }
 starcoin-storage = { package = "starcoin-storage", workspace = true }
 starcoin-types = { package = "starcoin-types", workspace = true }
 starcoin-state-tree = { workspace = true }
+starcoin-vm-types = { workspace = true }
 
 [dev-dependencies]
 starcoin-account-api = { package = "starcoin-account-api", workspace = true }

network-rpc/api/src/lib.rs

@@ -19,6 +19,7 @@ use starcoin_types::account_address::AccountAddress;
 use starcoin_types::account_state::AccountState;
 use starcoin_types::block::{Block, BlockHeader, BlockInfo, BlockNumber};
 use starcoin_types::transaction::{SignedUserTransaction, Transaction, TransactionInfo};
+use starcoin_vm_types::state_store::table::TableInfo;
 
 mod remote_chain_state;
 
@@ -286,6 +287,12 @@ pub trait NetworkRpc: Sized + Send + Sync + 'static {
         peer_id: PeerId,
         request: GetStateWithTableItemProof,
     ) -> BoxFuture<Result<StateWithTableItemProof>>;
+
+    fn get_state_table_info(
+        &self,
+        peer_id: PeerId,
+        request: GetTableInfo,
+    ) -> BoxFuture<Result<Option<TableInfo>>>;
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -294,3 +301,5 @@ pub struct GetStateWithTableItemProof {
     pub handle: TableHandle,
     pub key: Vec<u8>,
 }
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct GetTableInfo(pub AccountAddress);

network-rpc/api/src/remote_chain_state.rs

@@ -3,6 +3,7 @@
 
 use crate::{
     gen_client::NetworkRpcClient, GetAccountState, GetStateWithProof, GetStateWithTableItemProof,
+    GetTableInfo,
 };
 use anyhow::{anyhow, Result};
 use network_p2p_types::peer_id::PeerId;
@@ -14,7 +15,7 @@ use starcoin_types::account_address::AccountAddress;
 use starcoin_types::account_state::AccountState;
 use starcoin_types::state_set::{AccountStateSet, ChainStateSet};
 use starcoin_vm_types::state_store::state_key::StateKey;
-use starcoin_vm_types::state_store::table::TableHandle;
+use starcoin_vm_types::state_store::table::{TableHandle, TableInfo};
 
 #[derive(Clone)]
 pub struct RemoteChainStateReader {
@@ -121,6 +122,18 @@ impl ChainStateReader for RemoteChainStateReader {
         state_table_item_proof.verify(handle, key)?;
         Ok(state_table_item_proof)
     }
+
+    fn get_table_info(&self, address: AccountAddress) -> Result<Option<TableInfo>> {
+        let peer_id = self
+            .peer_id
+            .clone()
+            .ok_or_else(|| anyhow!("peer id not set"))?;
+        let req = GetTableInfo(address);
+        let client = self.client.clone();
+        let table_info: Option<TableInfo> =
+            futures::executor::block_on(client.get_state_table_info(peer_id, req))?;
+        Ok(table_info)
+    }
 }
 
 impl StateView for RemoteChainStateReader {

network-rpc/src/rpc.rs

@@ -11,8 +11,8 @@ use starcoin_chain_service::{ChainAsyncService, ChainReaderService};
 use starcoin_crypto::HashValue;
 use starcoin_network_rpc_api::{
     gen_server, BlockBody, GetAccountState, GetAccumulatorNodeByNodeHash, GetBlockHeadersByNumber,
-    GetBlockIds, GetStateWithProof, GetStateWithTableItemProof, GetTxnsWithHash, GetTxnsWithSize,
-    Ping, RpcRequest, MAX_BLOCK_HEADER_REQUEST_SIZE, MAX_BLOCK_INFO_REQUEST_SIZE,
+    GetBlockIds, GetStateWithProof, GetStateWithTableItemProof, GetTableInfo, GetTxnsWithHash,
+    GetTxnsWithSize, Ping, RpcRequest, MAX_BLOCK_HEADER_REQUEST_SIZE, MAX_BLOCK_INFO_REQUEST_SIZE,
     MAX_BLOCK_REQUEST_SIZE, MAX_TXN_REQUEST_SIZE,
 };
 use starcoin_service_registry::ServiceRef;
@@ -28,6 +28,7 @@ use starcoin_types::{
     block::{BlockHeader, BlockInfo, BlockNumber},
     transaction::{SignedUserTransaction, Transaction, TransactionInfo},
 };
+use starcoin_vm_types::state_store::table::TableInfo;
 use std::sync::Arc;
 
 pub struct NetworkRpcImpl {
@@ -251,6 +252,16 @@ impl gen_server::NetworkRpc for NetworkRpcImpl {
         Box::pin(fut)
     }
 
+    fn get_state_table_info(
+        &self,
+        _peer_id: PeerId,
+        request: GetTableInfo,
+    ) -> BoxFuture<Result<Option<TableInfo>>> {
+        let state_service = self.state_service.clone();
+        let fut = async move { state_service.get_table_info(request.0).await };
+        Box::pin(fut)
+    }
+
     fn get_account_state(
         &self,
         _peer_id: PeerId,

rpc/api/generated_rpc_schema/state.json

@@ -985,6 +985,43 @@
         }
       }
     },
+    {
+      "name": "state.get_table_info",
+      "params": [
+        {
+          "name": "address",
+          "schema": {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "title": "AccountAddress",
+            "type": "string",
+            "format": "AccountAddress"
+          }
+        }
+      ],
+      "result": {
+        "name": "Option < TableInfoView >",
+        "schema": {
+          "$schema": "http://json-schema.org/draft-07/schema#",
+          "title": "Nullable_table_info",
+          "type": [
+            "object",
+            "null"
+          ],
+          "required": [
+            "key_type",
+            "value_type"
+          ],
+          "properties": {
+            "key_type": {
+              "type": "string"
+            },
+            "value_type": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
     {
       "name": "state.get_with_table_item_proof",
       "params": [

rpc/api/src/state/mod.rs

@@ -4,7 +4,7 @@
 pub use self::gen_client::Client as StateClient;
 use crate::types::{
     AccountStateSetView, CodeView, ListCodeView, ListResourceView, ResourceView,
-    StateWithProofView, StateWithTableItemProofView, StrView, StructTagView,
+    StateWithProofView, StateWithTableItemProofView, StrView, StructTagView, TableInfoView,
 };
 use crate::FutureResult;
 use openrpc_derive::openrpc;
@@ -63,6 +63,10 @@ pub trait StateApi {
         state_root: HashValue,
     ) -> FutureResult<StrView<Vec<u8>>>;
 
+    /// Return the TableInfo according to queried AccountAddress
+    #[rpc(name = "state.get_table_info")]
+    fn get_table_info(&self, address: AccountAddress) -> FutureResult<Option<TableInfoView>>;
+
     /// Return the TableItem value  and provide a State Proof at `state_root`
     #[rpc(name = "state.get_with_table_item_proof")]
     fn get_with_table_item_proof(

rpc/api/src/types.rs

@@ -1180,7 +1180,7 @@ use starcoin_chain_api::{EventWithProof, TransactionInfoWithProof};
 use starcoin_types::account_address::AccountAddress;
 use starcoin_vm_types::move_resource::MoveResource;
 use starcoin_vm_types::state_store::state_key::{StateKey, TableItem};
-use starcoin_vm_types::state_store::table::TableHandle;
+use starcoin_vm_types::state_store::table::{TableHandle, TableInfo};
 pub use vm_status_translator::VmStatusExplainView;
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
@@ -1903,15 +1903,14 @@ impl From<BlockInfo> for BlockInfoView {
 #[serde(rename = "table_item")]
 pub struct TableItemView {
     handle: TableHandle,
-    #[schemars(with = "String")]
-    key: Vec<u8>,
+    key: StrView<Vec<u8>>,
 }
 
 impl From<TableItem> for TableItemView {
     fn from(table_item: TableItem) -> Self {
         Self {
             handle: table_item.handle,
-            key: table_item.key,
+            key: table_item.key.into(),
         }
     }
 }
@@ -1930,12 +1929,37 @@ impl From<StateKey> for StateKeyView {
             StateKey::AccessPath(access_path) => Self::AccessPath(access_path),
             StateKey::TableItem(table_item) => Self::TableItem(TableItemView {
                 handle: table_item.handle,
-                key: table_item.key,
+                key: table_item.key.into(),
             }),
         }
     }
 }
 
+#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(rename = "table_info")]
+pub struct TableInfoView {
+    key_type: TypeTagView,
+    value_type: TypeTagView,
+}
+
+impl From<TableInfo> for TableInfoView {
+    fn from(value: TableInfo) -> Self {
+        Self {
+            key_type: value.key_type.into(),
+            value_type: value.value_type.into(),
+        }
+    }
+}
+
+impl From<TableInfoView> for TableInfo {
+    fn from(value: TableInfoView) -> Self {
+        Self {
+            key_type: value.key_type.0,
+            value_type: value.value_type.0,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::types::{ByteCodeOrScriptFunction, FunctionId, StrView};

rpc/client/src/lib.rs

@@ -37,8 +37,8 @@ use starcoin_rpc_api::types::{
     DryRunTransactionRequest, FactoryAction, FunctionIdView, ListCodeView, ListResourceView,
     MintedBlockView, ModuleIdView, PeerInfoView, ResourceView, SignedMessageView,
     SignedUserTransactionView, StateWithProofView, StateWithTableItemProofView, StrView,
-    StructTagView, TransactionEventResponse, TransactionInfoView, TransactionInfoWithProofView,
-    TransactionRequest, TransactionView,
+    StructTagView, TableInfoView, TransactionEventResponse, TransactionInfoView,
+    TransactionInfoWithProofView, TransactionRequest, TransactionView,
 };
 use starcoin_rpc_api::{
     account::AccountClient, chain::ChainClient, contract_api::ContractClient, debug::DebugClient,
@@ -656,6 +656,14 @@ impl RpcClient {
         .map_err(map_err)
     }
 
+    pub fn state_get_table_info(
+        &self,
+        address: AccountAddress,
+    ) -> anyhow::Result<Option<TableInfoView>> {
+        self.call_rpc_blocking(|inner| inner.state_client.get_table_info(address))
+            .map_err(map_err)
+    }
+
     pub fn get_state_node_by_node_hash(
         &self,
         key_hash: HashValue,

rpc/client/src/remote_state_reader.rs

@@ -12,7 +12,7 @@ use starcoin_types::account_state::AccountState;
 use starcoin_types::block::BlockNumber;
 use starcoin_types::state_set::{AccountStateSet, ChainStateSet};
 use starcoin_vm_types::state_store::state_key::StateKey;
-use starcoin_vm_types::state_store::table::TableHandle;
+use starcoin_vm_types::state_store::table::{TableHandle, TableInfo};
 use std::str::FromStr;
 
 #[derive(Debug, Clone, Copy)]
@@ -109,6 +109,11 @@ impl<'a> ChainStateReader for RemoteStateReader<'a> {
             .state_get_with_table_item_proof_by_root(*handle, key.to_vec(), self.state_root)
             .map(Into::into)
     }
+    fn get_table_info(&self, address: AccountAddress) -> Result<Option<TableInfo>> {
+        self.client
+            .state_get_table_info(address)
+            .map(|v| v.map(Into::into))
+    }
 }
 
 impl<'a> StateView for RemoteStateReader<'a> {

rpc/server/src/module/state_rpc.rs

@@ -15,6 +15,7 @@ use starcoin_rpc_api::state::{
 use starcoin_rpc_api::types::{
     AccountStateSetView, AnnotatedMoveStructView, CodeView, ListCodeView, ListResourceView,
     ResourceView, StateWithProofView, StateWithTableItemProofView, StrView, StructTagView,
+    TableInfoView,
 };
 use starcoin_rpc_api::FutureResult;
 use starcoin_state_api::{ChainStateAsyncService, StateView};
@@ -185,6 +186,16 @@ where
         Box::pin(fut)
     }
 
+    fn get_table_info(&self, address: AccountAddress) -> FutureResult<Option<TableInfoView>> {
+        let fut = self
+            .service
+            .clone()
+            .get_table_info(address)
+            .map_ok(|v| v.map(Into::into))
+            .map_err(map_err);
+        Box::pin(fut)
+    }
+
     fn get_with_table_item_proof(
         &self,
         handle: TableHandle,

state/api/src/chain_state.rs

@@ -19,7 +19,7 @@ use starcoin_types::{
 use starcoin_vm_types::account_config::TABLE_HANDLE_ADDRESS_LIST;
 use starcoin_vm_types::genesis_config::ChainId;
 use starcoin_vm_types::on_chain_resource::{Epoch, EpochInfo, GlobalTimeOnChain};
-use starcoin_vm_types::state_store::table::TableHandle;
+use starcoin_vm_types::state_store::table::{TableHandle, TableInfo};
 use starcoin_vm_types::token::token_code::TokenCode;
 use starcoin_vm_types::{
     move_resource::MoveResource, on_chain_config::OnChainConfig, state_view::StateView,
@@ -135,6 +135,8 @@ pub trait ChainStateReader: StateView {
         handle: &TableHandle,
         key: &[u8],
     ) -> Result<StateWithTableItemProof>;
+
+    fn get_table_info(&self, address: AccountAddress) -> Result<Option<TableInfo>>;
 }
 
 pub trait ChainStateWriter {

state/api/src/lib.rs

@@ -21,7 +21,7 @@ use starcoin_types::state_set::AccountStateSet;
 use starcoin_vm_types::access_path::DataPath;
 use starcoin_vm_types::account_config::TABLE_HANDLE_ADDRESS_LIST;
 use starcoin_vm_types::move_resource::MoveResource;
-use starcoin_vm_types::state_store::table::TableHandle;
+use starcoin_vm_types::state_store::table::{TableHandle, TableInfo};
 pub use starcoin_vm_types::state_view::{StateReaderExt, StateView};
 
 mod chain_state;
@@ -92,6 +92,8 @@ pub trait ChainStateAsyncService: Clone + std::marker::Unpin + Send + Sync {
         key: Vec<u8>,
         state_root: HashValue,
     ) -> Result<StateWithTableItemProof>;
+
+    async fn get_table_info(self, address: AccountAddress) -> Result<Option<TableInfo>>;
 }
 
 #[async_trait::async_trait]
@@ -216,6 +218,15 @@ where
             panic!("Unexpect response type.")
         }
     }
+
+    async fn get_table_info(self, address: AccountAddress) -> Result<Option<TableInfo>> {
+        let response = self.send(StateRequest::GetTableInfo(address)).await??;
+        if let StateResponse::TableInfo(state) = response {
+            Ok(state)
+        } else {
+            panic!("Unexpect response type.")
+        }
+    }
 }
 
 #[cfg(test)]

state/api/src/message.rs

@@ -9,7 +9,7 @@ use starcoin_types::state_set::AccountStateSet;
 use starcoin_types::{
     access_path::AccessPath, account_address::AccountAddress, account_state::AccountState,
 };
-use starcoin_vm_types::state_store::table::TableHandle;
+use starcoin_vm_types::state_store::table::{TableHandle, TableInfo};
 
 #[derive(Debug, Clone)]
 pub enum StateRequest {
@@ -25,6 +25,7 @@ pub enum StateRequest {
     StateRoot(),
     GetWithTableItemProof(TableHandle, Vec<u8>),
     GetWithTableItemProofByRoot(TableHandle, Vec<u8>, HashValue),
+    GetTableInfo(AccountAddress),
 }
 
 impl ServiceRequest for StateRequest {
@@ -40,4 +41,5 @@ pub enum StateResponse {
     AccountStateSet(Option<AccountStateSet>),
     None,
     StateWithTableItemProof(Box<StateWithTableItemProof>),
+    TableInfo(Option<TableInfo>),
 }