fix: build deps

Author: ibrizsabin

Cargo.lock

@@ -131,11 +131,9 @@ impl<'a> IbcClient for CwIbcCoreContext<'a> {
         message: RawMsgUpdateClient,
     ) -> Result<Response, ContractError> {
         let client_id = to_ibc_client_id(&message.client_id)?;
-        let header = message
-            .header
-            .ok_or(ContractError::IbcClientError {
-                error: ClientError::MissingRawHeader,
-            })?;
+        let header = message.header.ok_or(ContractError::IbcClientError {
+            error: ClientError::MissingRawHeader,
+        })?;
 
         let client = self.get_light_client(deps.as_ref().storage, &client_id)?;
         let client_state = self.client_state(deps.as_ref(), &client_id)?;
@@ -151,7 +149,7 @@ impl<'a> IbcClient for CwIbcCoreContext<'a> {
 
         let sub_msg: SubMsg = client.update_client(&client_id, &header)?;
         cw_println!(
-            deps,
+            deps.api,
             "Called Update Client On Lightclient for client id:{}",
             &message.client_id
         );
@@ -327,7 +325,7 @@ impl<'a> IbcClient for CwIbcCoreContext<'a> {
             cosmwasm_std::SubMsgResult::Ok(result) => match result.data {
                 Some(data) => {
                     let update_client_response: UpdateClientResponse = from_binary_response(&data)?;
-                    cw_println!(deps, "Received Client Update Callback with data");
+                    cw_println!(deps.api, "Received Client Update Callback with data");
                     let client_id: ClientId =
                         self.get_callback_data(deps.as_ref().storage, EXECUTE_UPDATE_CLIENT)?;
                     self.clear_callback_data(deps.storage, EXECUTE_UPDATE_CLIENT);

contracts/cosmwasm-vm/cw-ibc-core/src/ics02_client/handler.rs

@@ -208,7 +208,7 @@ impl<'a> CwIbcCoreContext<'a> {
             connection_end.delay_period(),
         );
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenAck]: Expected conn end {:?}",
             expected_connection_end
         );
@@ -338,7 +338,7 @@ impl<'a> CwIbcCoreContext<'a> {
         let prefix = self.commitment_prefix(deps.as_ref(), &env);
 
         cw_println!(
-            deps,
+            deps.api,
             "prefix_on_b is {:?}",
             from_utf8(&prefix.clone().into_vec()).unwrap()
         );
@@ -354,21 +354,21 @@ impl<'a> CwIbcCoreContext<'a> {
         );
 
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenTry]: expected counterpart connection_end:{:?}",
             HexString::from_bytes(&expected_connection_end.encode_vec().unwrap())
         );
 
         let consensus_state = self.consensus_state(deps.as_ref(), &client_id, &proof_height)?;
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenTry]: root: {:?} ",
             HexString::from_bytes(consensus_state.root().as_bytes())
         );
         let counterparty_connection_path =
             commitment::connection_path(&counterparty_connection_id.clone().unwrap());
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenTry]: connkey: {:?}",
             HexString::from_bytes(&counterparty_connection_path)
         );
@@ -383,13 +383,13 @@ impl<'a> CwIbcCoreContext<'a> {
 
         // this is verifying tendermint client state and shouldn't have icon-client as an argument
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenTry]: payload client state path {:?}",
             &counterparty_client_id
         );
         let client_state_path = commitment::client_state_path(&counterparty_client_id);
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenTry]: the clientstate value is  {:?}",
             message_client_state.value
         );
@@ -429,7 +429,7 @@ impl<'a> CwIbcCoreContext<'a> {
         let connection_id = self.generate_connection_idenfier(deps.storage)?;
 
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenTryReply]: connection id is{:?}",
             connection_id
         );
@@ -500,7 +500,7 @@ impl<'a> CwIbcCoreContext<'a> {
         }
         let prefix = self.commitment_prefix(deps.as_ref(), &env);
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenConfirm]: Our Connection {:?}",
             connection_end
         );
@@ -509,7 +509,11 @@ impl<'a> CwIbcCoreContext<'a> {
         let counterparty_client_id = counterparty.client_id();
         let counterparty_prefix = counterparty.prefix();
         let counterparty_conn_id = counterparty.connection_id().cloned();
-        cw_println!(deps.api, "[ConnOpenConfirm]: CounterParty  {:?}", &counterparty);
+        cw_println!(
+            deps.api,
+            "[ConnOpenConfirm]: CounterParty  {:?}",
+            &counterparty
+        );
 
         ensure_connection_state(&connection_id, &connection_end, &State::TryOpen)?;
 
@@ -535,7 +539,7 @@ impl<'a> CwIbcCoreContext<'a> {
         client.verify_connection_open_confirm(deps.as_ref(), verify_connection_state, client_id)?;
 
         cw_println!(
-            deps,
+            deps.api,
             "[ConnOpenConfirmReply]: CounterParty  {:?}",
             counterparty
         );

contracts/cosmwasm-vm/cw-ibc-core/src/ics03_connection/handler.rs

@@ -64,7 +64,7 @@ impl<'a> ValidateChannel for CwIbcCoreContext<'a> {
     ) -> Result<cosmwasm_std::Response, ContractError> {
         // connection hops should be 1
         cw_println!(
-            deps,
+            deps.api,
             "inside validate channel open init: input parameter: {:?}",
             message
         );
@@ -180,7 +180,7 @@ impl<'a> ValidateChannel for CwIbcCoreContext<'a> {
         let source_channel = channel_end.remote.channel_id.clone().unwrap();
 
         cw_println!(
-            deps,
+            deps.api,
             "stoed: channel id: {:?}  portid :{:?} channel_end :{:?}",
             &dest_channel,
             &dest_port,

contracts/cosmwasm-vm/cw-ibc-core/src/ics04_channel/handler.rs

@@ -114,11 +114,15 @@ impl<'a> CwIbcCoreContext<'a> {
         );
         cw_println!(deps.api, "packet is -> {:?}", msg.packet);
         cw_println!(
-            deps,
+            deps.api,
             "packet.data is -> {:?}",
             HexString::from_bytes(&packet.data)
         );
-        cw_println!(deps.api, "expected commitement created {:?}", packet.sequence);
+        cw_println!(
+            deps.api,
+            "expected commitement created {:?}",
+            packet.sequence
+        );
 
         let commitment_path_on_a = commitment::packet_commitment_path(
             &src_port,

contracts/cosmwasm-vm/cw-ibc-core/src/ics04_channel/packet/receive_packet.rs

@@ -165,7 +165,7 @@ impl<'a> CwIbcCoreContext<'a> {
             verify_channel_state,
             next_seq_recv_verification_result,
         )?;
-        cw_println!(deps, "Light Client Validation Passed");
+        cw_println!(deps.api, "Light Client Validation Passed");
 
         if let Order::Ordered = channel_end.ordering {
             channel_end.state = State::Closed;

contracts/cosmwasm-vm/cw-ibc-core/src/ics04_channel/packet/timeout_on_close.rs

@@ -536,7 +536,7 @@ fn check_for_update_client_message() {
 
     let update_client_message = RawMsgUpdateClient {
         client_id: client_id.to_string(),
-        client_message: Some(client_state.to_any()),
+        header: Some(client_state.to_any()),
         signer: signer.to_string(),
     };
 
@@ -598,7 +598,7 @@ fn fails_on_updating_non_existing_client() {
     let signer = Signer::from_str("new_signer").unwrap();
     let update_client_message = RawMsgUpdateClient {
         client_id: client_id.to_string(),
-        client_message: Some(client_state.to_any()),
+        header: Some(client_state.to_any()),
         signer: signer.to_string(),
     };
 

contracts/cosmwasm-vm/cw-ibc-core/tests/test_client.rs

@@ -182,7 +182,7 @@ fn test_for_update_client_execution_messages() {
 
     let msg_hex = RawMsgUpdateClient {
         client_id: "iconclient-0".to_string(),
-        client_message: Some(signed_header.to_any()),
+        header: Some(signed_header.to_any()),
         signer: "signeraddress".to_string(),
     };
 

contracts/cosmwasm-vm/cw-ibc-core/tests/test_execution_messages.rs

@@ -1,5 +1,5 @@
 use crate::constants::TRUST_LEVEL;
-use crate::state::CwContext;
+
 use crate::traits::{ConsensusStateUpdate, IContext, ILightClient};
 use crate::ContractError;
 use common::icon::icon::lightclient::v1::ConsensusState;
@@ -11,12 +11,11 @@ use cosmwasm_std::Addr;
 use cw_common::cw_println;
 use prost::Message;
 
-pub struct IconClient<C:IContext> {
+pub struct IconClient<C: IContext> {
     context: C,
 }
 
-impl<C:IContext> IconClient<C> {
-    
+impl<C: IContext> IconClient<C> {
     pub fn new(context: C) -> Self {
         Self { context }
     }
@@ -98,7 +97,7 @@ impl<C:IContext> IconClient<C> {
     }
 }
 
-impl<C:IContext> ILightClient for IconClient<C> {
+impl<C: IContext> ILightClient for IconClient<C> {
     type Error = crate::ContractError;
 
     fn create_client(

contracts/cosmwasm-vm/cw-light-client-common/src/light_client.rs

@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use crate::{
     state::{CLIENT_STATES, CONFIG, CONSENSUS_STATES, PROCESSED_HEIGHTS, PROCESSED_TIMES},
-    traits::{Config},
+    traits::Config,
     ContractError,
 };
 use common::{
@@ -21,21 +21,20 @@ use prost::Message;
 
 pub struct QueryHandler;
 
-
 impl QueryHandler {
     pub fn get_consensus_state(
         storage: &dyn Storage,
         client_id: &str,
         height: u64,
     ) -> Result<ConsensusState, ContractError> {
         let data = CONSENSUS_STATES
-        .load(storage, (client_id.to_string(), height))
-        .map_err(|_e| ContractError::ConsensusStateNotFound {
-            height,
-            client_id: client_id.to_string(),
-        })?;
-    let state = ConsensusState::decode(data.as_slice()).map_err(ContractError::DecodeError)?;
-    Ok(state)
+            .load(storage, (client_id.to_string(), height))
+            .map_err(|_e| ContractError::ConsensusStateNotFound {
+                height,
+                client_id: client_id.to_string(),
+            })?;
+        let state = ConsensusState::decode(data.as_slice()).map_err(ContractError::DecodeError)?;
+        Ok(state)
     }
 
     pub fn get_client_state(
@@ -77,7 +76,6 @@ impl QueryHandler {
             })
     }
 
-
     pub fn get_config(storage: &dyn Storage) -> Result<Config, ContractError> {
         CONFIG
             .load(storage)

contracts/cosmwasm-vm/cw-light-client-common/src/query_handler.rs

@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use common::icon::icon::lightclient::v1::ClientState;
 use common::icon::icon::lightclient::v1::ConsensusState;
 
@@ -13,9 +11,8 @@ use cosmwasm_std::Storage;
 use cw_storage_plus::{Item, Map};
 use debug_print::debug_eprintln;
 
-use prost::Message;
 use crate::query_handler::QueryHandler;
-
+use prost::Message;
 
 use crate::traits::Config;
 use crate::traits::IContext;
@@ -32,7 +29,6 @@ pub struct CwContext<'a> {
     pub storage: &'a mut dyn Storage,
     pub api: &'a dyn Api,
     pub env: Env,
-
 }
 
 impl<'a> CwContext<'a> {
@@ -46,18 +42,15 @@ impl<'a> CwContext<'a> {
 }
 
 impl<'a> IContext for CwContext<'a> {
-   
-   
-    
-    fn get_client_state(&self, client_id: &str) -> Result<ClientState,ContractError> {
+    fn get_client_state(&self, client_id: &str) -> Result<ClientState, ContractError> {
         QueryHandler::get_client_state(self.storage, client_id)
     }
 
     fn insert_client_state(
         &mut self,
         client_id: &str,
         state: ClientState,
-    ) -> Result<(),ContractError> {
+    ) -> Result<(), ContractError> {
         let data = state.encode_to_vec();
         CLIENT_STATES
             .save(self.storage, client_id.to_string(), &data)
@@ -84,7 +77,7 @@ impl<'a> IContext for CwContext<'a> {
             .map_err(|_e| ContractError::FailedToSaveClientState)
     }
 
-    fn get_timestamp_at_height(&self, client_id: &str, height: u64) -> Result<u64,ContractError> {
+    fn get_timestamp_at_height(&self, client_id: &str, height: u64) -> Result<u64, ContractError> {
         QueryHandler::get_timestamp_at_height(self.storage, client_id, height)
     }
 
@@ -106,11 +99,11 @@ impl<'a> IContext for CwContext<'a> {
             .map(|addr| addr.to_vec())
     }
 
-    fn get_config(&self) -> Result<Config,ContractError> {
+    fn get_config(&self) -> Result<Config, ContractError> {
         QueryHandler::get_config(self.storage)
     }
 
-    fn insert_config(&mut self, config: &Config) -> Result<(),ContractError> {
+    fn insert_config(&mut self, config: &Config) -> Result<(), ContractError> {
         CONFIG
             .save(self.storage, config)
             .map_err(|_e| ContractError::FailedToSaveConfig)
@@ -162,23 +155,23 @@ impl<'a> IContext for CwContext<'a> {
         QueryHandler::get_processed_blocknumber_at_height(self.storage, client_id, height)
     }
 
-    fn ensure_ibc_host(&self, caller: cosmwasm_std::Addr) -> Result<(),ContractError> {
+    fn ensure_ibc_host(&self, caller: cosmwasm_std::Addr) -> Result<(), ContractError> {
         let config = self.get_config()?;
         if caller != config.ibc_host {
             return Err(ContractError::Unauthorized {});
         }
         Ok(())
     }
-    fn ensure_owner(&self, caller: cosmwasm_std::Addr) -> Result<(),ContractError> {
+    fn ensure_owner(&self, caller: cosmwasm_std::Addr) -> Result<(), ContractError> {
         let config = self.get_config()?;
         debug_eprintln!("owner {:?} caller {}", config.owner, caller.to_string());
         if caller != config.owner {
             return Err(ContractError::Unauthorized {});
         }
         Ok(())
     }
-    fn api(&self)->& dyn Api {
-        return self.api
+    fn api(&self) -> &dyn Api {
+        self.api
     }
 }