Merge pull request #104 from datachainlab/specify-client-id-externally

Allow client ID to be specified externally in `init_client`

Signed-off-by: Jun Kimura <jun.kimura@datachain.jp>

Author: bluele

enclave-modules/ecall-handler/src/light_client/errors.rs

@@ -15,6 +15,14 @@ define_error! {
         SealedEnclaveKeyNotFound
         |_| { "Sealed EnclaveKey not found" },
 
+        ClientAlreadyExists
+        {
+            client_id: String
+        }
+        |e| {
+            format_args!("client already exists: client_id={}", e.client_id)
+        },
+
         LightClient
         [light_client::Error]
         |_| { "LightClient error" },

enclave-modules/ecall-handler/src/light_client/init_client.rs

@@ -21,24 +21,22 @@ pub fn init_client<R: LightClientResolver, S: KVStore, K: Signer>(
     let ek = ctx.get_enclave_key();
     let res = lc.create_client(ctx, any_client_state.clone(), any_consensus_state.clone())?;
     let client_type = lc.client_type();
-    let client_id = gen_client_id(client_type.clone(), ctx.client_counter()?)?;
+    let client_id = ClientId::from_str(&input.client_id)?;
+    client_id.validate(&client_type)?;
 
+    if ctx.client_exists(&client_id) {
+        return Err(Error::client_already_exists(client_id.to_string()));
+    }
     ctx.store_client_type(client_id.clone(), client_type)?;
     ctx.store_any_client_state(client_id.clone(), any_client_state)?;
     ctx.store_any_consensus_state(client_id.clone(), res.height, any_consensus_state)?;
-    ctx.increase_client_counter();
 
     let proof = if res.prove {
         prove_commitment(ek, input.signer, res.message)?
     } else {
         CommitmentProof::new_with_no_signature(res.message.to_bytes())
     };
     Ok(LightClientResponse::InitClient(InitClientResponse {
-        client_id,
         proof,
     }))
 }
-
-fn gen_client_id(client_type: String, counter: u64) -> Result<ClientId, Error> {
-    Ok(ClientId::from_str(&format!("{}-{}", client_type, counter))?)
-}

enclave-modules/ecall-handler/src/light_client/query.rs

@@ -10,13 +10,21 @@ pub fn query_client<R: LightClientResolver, S: KVStore, K: Signer>(
     ctx: &mut Context<R, S, K>,
     input: QueryClientInput,
 ) -> Result<LightClientResponse, Error> {
-    let lc = get_light_client_by_client_id(ctx, &input.client_id)?;
-    let any_client_state = ctx.client_state(&input.client_id)?;
-    let any_consensus_state =
-        ctx.consensus_state(&input.client_id, &lc.latest_height(ctx, &input.client_id)?)?;
-
-    Ok(LightClientResponse::QueryClient(QueryClientResponse {
-        any_client_state,
-        any_consensus_state,
-    }))
+    if ctx.client_exists(&input.client_id) {
+        let lc = get_light_client_by_client_id(ctx, &input.client_id)?;
+        let any_client_state = ctx.client_state(&input.client_id)?;
+        let any_consensus_state =
+            ctx.consensus_state(&input.client_id, &lc.latest_height(ctx, &input.client_id)?)?;
+        Ok(LightClientResponse::QueryClient(QueryClientResponse {
+            found: true,
+            any_client_state: Some(any_client_state),
+            any_consensus_state: Some(any_consensus_state),
+        }))
+    } else {
+        Ok(LightClientResponse::QueryClient(QueryClientResponse {
+            found: false,
+            any_client_state: None,
+            any_consensus_state: None,
+        }))
+    }
 }

modules/ecall-commands/src/light_client.rs

@@ -41,6 +41,7 @@ impl EnclaveKeySelector for LightClientCommand {
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct InitClientInput {
+    pub client_id: String,
     pub any_client_state: Any,
     pub any_consensus_state: Any,
     pub current_timestamp: Time,
@@ -105,7 +106,6 @@ pub enum LightClientResponse {
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct InitClientResponse {
-    pub client_id: ClientId,
     pub proof: CommitmentProof,
 }
 
@@ -123,6 +123,7 @@ pub struct VerifyNonMembershipResponse(pub CommitmentProof);
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct QueryClientResponse {
-    pub any_client_state: Any,
-    pub any_consensus_state: Any,
+    pub found: bool,
+    pub any_client_state: Option<Any>,
+    pub any_consensus_state: Option<Any>,
 }

modules/ecall-commands/src/msgs.rs

@@ -23,6 +23,7 @@ impl TryFrom<MsgCreateClient> for InitClientInput {
             .ok_or_else(|| Error::invalid_argument("consensus_state must be non-nil".into()))?
             .into();
         Ok(Self {
+            client_id: msg.client_id,
             any_client_state,
             any_consensus_state,
             current_timestamp: Time::now(),
@@ -116,7 +117,6 @@ impl TryFrom<MsgQueryClientRequest> for QueryClientInput {
 impl From<InitClientResponse> for MsgCreateClientResponse {
     fn from(res: InitClientResponse) -> Self {
         Self {
-            client_id: res.client_id.to_string(),
             message: res.proof.message,
             signer: res.proof.signer.into(),
             signature: res.proof.signature,
@@ -167,8 +167,9 @@ impl From<VerifyNonMembershipResponse> for MsgVerifyNonMembershipResponse {
 impl From<QueryClientResponse> for MsgQueryClientResponse {
     fn from(res: QueryClientResponse) -> Self {
         Self {
-            client_state: Some(res.any_client_state.into()),
-            consensus_state: Some(res.any_consensus_state.into()),
+            found: res.found,
+            client_state: res.any_client_state.map(Into::into),
+            consensus_state: res.any_consensus_state.map(Into::into),
         }
     }
 }

modules/enclave-api/src/api/proto.rs

@@ -11,10 +11,11 @@ use store::transaction::CommitStore;
 
 pub trait EnclaveProtoAPI<S: CommitStore>: EnclaveCommandAPI<S> {
     fn proto_create_client(&self, msg: MsgCreateClient) -> Result<MsgCreateClientResponse> {
+        let client_id = msg.client_id.clone();
         let res = self.init_client(msg.try_into()?)?;
         info!(
             "create_client: client_id={} message={{{}}}",
-            res.client_id,
+            client_id,
             res.proof.message()?
         );
         Ok(res.into())

modules/light-client/src/context.rs

@@ -1,7 +1,7 @@
 use crate::types::{Any, ClientId, Height, Time};
 use crate::{
     errors::Error,
-    path::{ClientConsensusStatePath, ClientStatePath, ClientTypePath, NEXT_CLIENT_SEQUENCE},
+    path::{ClientConsensusStatePath, ClientStatePath, ClientTypePath},
     prelude::*,
 };
 use store::KVStore;
@@ -12,6 +12,12 @@ pub trait HostContext {
 }
 
 pub trait ClientReader: KVStore {
+    /// Returns `true` if the client exists in the store.
+    fn client_exists(&self, client_id: &ClientId) -> bool {
+        self.get(format!("{}", ClientTypePath::new(client_id)).as_bytes())
+            .is_some()
+    }
+
     /// Returns the ClientType for the given identifier `client_id`.
     fn client_type(&self, client_id: &ClientId) -> Result<String, Error> {
         let value = self.get(format!("{}", ClientTypePath::new(client_id)).as_bytes());
@@ -54,19 +60,6 @@ pub trait ClientReader: KVStore {
                 .0,
         )
     }
-
-    /// Returns a natural number, counting how many clients have been created thus far.
-    /// The value of this counter should increase only via method `ClientKeeper::increase_client_counter`.
-    fn client_counter(&self) -> Result<u64, Error> {
-        match self.get(NEXT_CLIENT_SEQUENCE.as_bytes()) {
-            Some(bz) => {
-                let mut b: [u8; 8] = Default::default();
-                b.copy_from_slice(&bz);
-                Ok(u64::from_be_bytes(b))
-            }
-            None => Ok(0),
-        }
-    }
 }
 
 pub trait ClientKeeper: ClientReader {
@@ -106,17 +99,6 @@ pub trait ClientKeeper: ClientReader {
         self.set(format!("{}", path).into_bytes(), bz);
         Ok(())
     }
-
-    /// Called upon client creation.
-    /// Increases the counter which keeps track of how many clients have been created.
-    /// Should never fail.
-    fn increase_client_counter(&mut self) {
-        let next_counter = <Self as ClientReader>::client_counter(self).unwrap() + 1;
-        self.set(
-            NEXT_CLIENT_SEQUENCE.as_bytes().to_vec(),
-            next_counter.to_be_bytes().to_vec(),
-        );
-    }
 }
 
 pub trait HostClientReader: HostContext + ClientReader {}

modules/light-client/src/ibc.rs

@@ -138,11 +138,7 @@ impl<'a, ClientState: Ics02ClientState, ConsensusState: Ics02ConsensusState> Val
     }
 
     fn client_counter(&self) -> Result<u64, ibc::core::ContextError> {
-        self.parent.client_counter().map_err(|e| {
-            ContextError::ClientError(ClientError::ClientSpecific {
-                description: e.to_string(),
-            })
-        })
+        unimplemented!()
     }
 
     fn connection_end(

modules/light-client/src/path.rs

@@ -1,8 +1,6 @@
 use crate::types::{ClientId, Height};
 use derive_more::Display;
 
-pub static NEXT_CLIENT_SEQUENCE: &str = "nextClientSequence";
-
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Display)]
 #[display(fmt = "clients/{_0}/clientType")]
 pub struct ClientTypePath(pub ClientId);

modules/types/src/errors.rs

@@ -46,6 +46,26 @@ define_error! {
             |_| {
                 "identifier cannot be empty"
             },
+        ClientIdInvalidFormat
+            { id: String }
+            |e| {
+                format_args!("identifier `{}` must be in the format `{{client_type}}-{{counter}}`", e.id)
+            },
+        ClientIdInvalidClientType
+            { id: String, client_type: String }
+            |e| {
+                format_args!("identifier `{}` must have client type `{}`", e.id, e.client_type)
+            },
+        ClientIdInvalidCounter
+            { id: String }
+            |e| {
+                format_args!("identifier `{}` must have a valid counter", e.id)
+            },
+        ClientIdInvalidCounterParseIntError
+            { id: String, e: core::num::ParseIntError }
+            |e| {
+                format_args!("identifier `{}` counter parse error: {}", e.id, e.e)
+            },
         MrenclaveBytesConversion
             {
                 bz: Vec<u8>,