Voyager packets

cosmwasm/union-ibc/app/ucs00-pingpong/src/contract.rs

@@ -1,3 +1,4 @@
+use cosmwasm_schema::cw_serde;
 #[cfg(not(feature = "library"))]
 use cosmwasm_std::entry_point;
 use cosmwasm_std::{wasm_execute, DepsMut, Env, MessageInfo, Response, StdError};
@@ -59,7 +60,7 @@ pub fn execute(
                     &config.ibc_host,
                     &union_ibc_msg::msg::ExecuteMsg::WriteAcknowledgement(
                         MsgWriteAcknowledgement {
-                            channel_id: packet.source_channel,
+                            channel_id: packet.destination_channel,
                             packet,
                             acknowledgement: ack_success().into(),
                         },
@@ -81,6 +82,14 @@ pub fn execute(
     }
 }
 
+#[cw_serde]
+pub struct MigrateMsg {}
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn migrate(_deps: DepsMut, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
+    Ok(Response::new())
+}
+
 fn enforce_version(version: &str, counterparty_version: Option<&str>) -> Result<(), ContractError> {
     if version != PROTOCOL_VERSION {
         return Err(ContractError::InvalidIbcVersion {

cosmwasm/union-ibc/core/Cargo.toml

@@ -27,6 +27,7 @@ serde           = { workspace = true, features = ["derive"] }
 serde_json      = { workspace = true }
 sha2            = { workspace = true }
 sha3            = { workspace = true }
+strum = { version = "0.26.3", features = ["derive"] }
 thiserror       = { workspace = true }
 union-ibc-msg   = { workspace = true }
 unionlabs       = { workspace = true, features = ["ethabi"] }

cosmwasm/union-ibc/core/msg/src/query.rs

@@ -1,3 +1,5 @@
+use unionlabs::hash::H256;
+
 #[derive(serde::Serialize, serde::Deserialize)]
 #[serde(deny_unknown_fields, rename_all = "snake_case")]
 pub enum QueryMsg {
@@ -10,4 +12,6 @@ pub enum QueryMsg {
     GetConnection { connection_id: u32 },
     GetChannel { channel_id: u32 },
     GetChannels { contract: String },
+    GetBatchPackets { channel_id: u32, batch_hash: H256 },
+    GetBatchReceipts { channel_id: u32, batch_hash: H256 },
 }

cosmwasm/union-ibc/core/src/contract.rs

@@ -25,7 +25,7 @@ use union_ibc_msg::{
 use unionlabs::{
     ethereum::keccak256,
     hash::{hash_v2::HexPrefixed, H256},
-    ics24::ethabi::COMMITMENT_MAGIC,
+    ics24::ethabi::{BatchPacketsPath, BatchReceiptsPath, COMMITMENT_MAGIC},
 };
 
 use crate::{
@@ -60,11 +60,11 @@ pub mod events {
         pub const CLOSE_CONFIRM: &str = "channel_close_confirm";
     }
     pub mod packet {
-        pub const SEND: &str = "packet_send";
-        pub const RECV: &str = "packet_recv";
-        pub const INTENT_RECV: &str = "packet_intent_recv";
-        pub const ACK: &str = "packet_ack";
-        pub const TIMEOUT: &str = "packet_timeout";
+        pub const SEND: &str = "send_packet";
+        pub const RECV: &str = "recv_packet";
+        pub const INTENT_RECV: &str = "intent_recv_packet";
+        pub const ACK: &str = "ack_packet";
+        pub const TIMEOUT: &str = "timeout_packet";
         pub const BATCH_SEND: &str = "batch_send";
         pub const BATCH_ACKS: &str = "batch_acks";
     }
@@ -445,10 +445,15 @@ fn batch_acks(
         let commitment = deps.storage.get(commitment_key.as_ref());
         match commitment {
             Some(acknowledgement) => {
+                let expected_ack = commit_ack(ack.to_vec());
+
                 if acknowledgement == COMMITMENT_MAGIC.as_ref() {
                     return Err(ContractError::AcknowledgementIsEmpty);
-                } else if acknowledgement != commit_ack(ack.to_vec()).as_ref() {
-                    return Err(ContractError::AcknowledgementMismatch);
+                } else if acknowledgement != expected_ack.as_ref() {
+                    return Err(ContractError::AcknowledgementMismatch {
+                        found: acknowledgement.into(),
+                        expected: expected_ack.into(),
+                    });
                 }
             }
             None => return Err(ContractError::PacketCommitmentNotFound),
@@ -620,11 +625,11 @@ fn delete_packet_commitment(
 }
 
 fn commit_packet(packet: &Packet) -> H256 {
-    commit(packet.abi_encode_params())
+    commit(packet.abi_encode())
 }
 
 fn commit_packets(packets: &[Packet]) -> H256 {
-    commit(packets.abi_encode_params())
+    commit(packets.abi_encode())
 }
 
 fn register_client(
@@ -1395,7 +1400,11 @@ fn write_acknowledgement(
     // make sure the caller owns the channel
     let port_id = CHANNEL_OWNER.load(deps.storage, channel_id)?;
     if port_id != sender {
-        return Err(ContractError::Unauthorized);
+        return Err(ContractError::Unauthorized {
+            channel_id,
+            owner: port_id,
+            caller: sender,
+        });
     }
 
     let commitment_key =
@@ -1445,7 +1454,11 @@ fn send_packet(
 
     let port_id = CHANNEL_OWNER.load(deps.storage, source_channel)?;
     if port_id != sender {
-        return Err(ContractError::Unauthorized);
+        return Err(ContractError::Unauthorized {
+            channel_id: source_channel,
+            owner: port_id,
+            caller: sender,
+        });
     }
 
     let channel = ensure_channel_state(deps.as_ref(), source_channel)?;
@@ -1467,7 +1480,7 @@ fn send_packet(
     store_commit(deps.branch(), &commitment_key, &COMMITMENT_MAGIC)?;
 
     Ok(Response::new()
-        .add_event(Event::new("send_packet").add_attribute(
+        .add_event(Event::new(events::packet::SEND).add_attribute(
             events::attribute::PACKET,
             serde_json::to_string(&packet).unwrap(),
         ))
@@ -1518,6 +1531,13 @@ fn store_commit(deps: DepsMut, key: &H256, value: &H256) -> Result<(), ContractE
     Ok(())
 }
 
+fn read_commit(deps: Deps, key: &H256) -> Option<H256> {
+    deps.storage.get(key.as_ref()).map(|bz| {
+        bz.try_into()
+            .expect("H256 is the only value ever written to this storage; qed;")
+    })
+}
+
 fn save_connection(
     deps: DepsMut,
     connection_id: u32,
@@ -1664,6 +1684,34 @@ pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Result<Binary, ContractErr
             let connection = CONNECTIONS.load(deps.storage, connection_id)?;
             Ok(to_json_binary(&connection)?)
         }
+        QueryMsg::GetBatchPackets {
+            channel_id,
+            batch_hash,
+        } => {
+            let commit = read_commit(
+                deps,
+                &BatchPacketsPath {
+                    channel_id,
+                    batch_hash,
+                }
+                .key(),
+            );
+            Ok(to_json_binary(&commit)?)
+        }
+        QueryMsg::GetBatchReceipts {
+            channel_id,
+            batch_hash,
+        } => {
+            let commit = read_commit(
+                deps,
+                &BatchReceiptsPath {
+                    channel_id,
+                    batch_hash,
+                }
+                .key(),
+            );
+            Ok(to_json_binary(&commit)?)
+        }
     }
 }