feat(ibc-union): normalize batch events (#4048)

Author: hussein-aitlahcen

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

@@ -91,11 +91,11 @@ pub mod events {
         pub const PACKET_DATA: &str = "packet_data";
         pub const PACKET_TIMEOUT_HEIGHT: &str = "packet_timeout_height";
         pub const PACKET_TIMEOUT_TIMESTAMP: &str = "packet_timeout_timestamp";
-        pub const PACKETS: &str = "packets";
-        pub const ACKS: &str = "acks";
+        pub const BATCH_HASH: &str = "batch_hash";
         pub const MAKER: &str = "maker";
         pub const MAKER_MSG: &str = "maker_msg";
         pub const ACKNOWLEDGEMENT: &str = "acknowledgement";
+        pub const ACKNOWLEDGEMENT_HASH: &str = "acknowledgement_hash";
         pub const CLIENT_TYPE: &str = "client_type";
         pub const CLIENT_ADDRESS: &str = "client_address";
         pub const COUNTERPARTY_CHAIN_ID: &str = "counterparty_chain_id";
@@ -520,10 +520,15 @@ fn batch_send(deps: DepsMut, packets: Vec<Packet>) -> ContractResult {
         return Err(ContractError::NotEnoughPackets);
     }
     let channel_id = packets[0].source_channel_id;
-    let serialized_packets =
-        serde_json_wasm::to_string(&packets).expect("packet serialization is infallible; qed;");
+    let batch_hash = commit_packets(&packets);
     let batch_commitment_key = BatchPacketsPath::from_packets(&packets).key();
+    let mut events = Vec::new();
     for packet in packets {
+        events.push(
+            Event::new(events::packet::BATCH_SEND)
+                .add_attributes([packet_to_attr_hash(&packet)])
+                .add_attribute(events::attribute::BATCH_HASH, batch_hash.to_string()),
+        );
         if packet.source_channel_id != channel_id {
             return Err(ContractError::BatchSameChannelOnly);
         }
@@ -537,53 +542,45 @@ fn batch_send(deps: DepsMut, packets: Vec<Packet>) -> ContractResult {
         }
     }
     store_commit(deps, &batch_commitment_key, &COMMITMENT_MAGIC);
-    Ok(
-        Response::new().add_event(Event::new(events::packet::BATCH_SEND).add_attributes([
-            (events::attribute::CHANNEL_ID, channel_id.to_string()),
-            (events::attribute::PACKETS, serialized_packets),
-        ])),
-    )
+    Ok(Response::new().add_events(events))
 }
 
 fn batch_acks(deps: DepsMut, packets: Vec<Packet>, acks: Vec<Bytes>) -> ContractResult {
     if packets.len() < 2 {
         return Err(ContractError::NotEnoughPackets);
     }
     let channel_id = packets[0].destination_channel_id;
+    let batch_hash = commit_packets(&packets);
     let batch_commitment_key = BatchReceiptsPath::from_packets(&packets).key();
-    let serialized_packets =
-        serde_json_wasm::to_string(&packets).expect("packet serialization is infallible; qed;");
-    let serialized_acks =
-        serde_json_wasm::to_string(&acks).expect("bytes serialization is infallible; qed;");
+    let mut events = Vec::new();
     for (packet, ack) in packets.into_iter().zip(acks.iter()) {
+        events.push(
+            Event::new(events::packet::BATCH_ACKS)
+                .add_attributes([packet_to_attr_hash(&packet)])
+                .add_attribute(events::attribute::BATCH_HASH, batch_hash.to_string()),
+        );
         if packet.destination_channel_id != channel_id {
             return Err(ContractError::BatchSameChannelOnly);
         }
         let commitment_key = BatchReceiptsPath::from_packets(&[packet]).key();
         let commitment = read_commit(deps.as_ref(), &commitment_key);
         match commitment {
-            Some(acknowledgement) => {
-                let expected_ack = commit_ack(ack);
-                if acknowledgement == COMMITMENT_MAGIC {
+            Some(ack_commitment) => {
+                let ack_commitment_expected = commit_ack(ack);
+                if ack_commitment == COMMITMENT_MAGIC {
                     return Err(ContractError::AcknowledgementIsEmpty);
-                } else if acknowledgement != expected_ack {
+                } else if ack_commitment != ack_commitment_expected {
                     return Err(ContractError::AcknowledgementMismatch {
-                        found: acknowledgement.into(),
-                        expected: expected_ack.into(),
+                        found: ack_commitment.into(),
+                        expected: ack_commitment_expected.into(),
                     });
                 }
             }
             None => return Err(ContractError::PacketCommitmentNotFound),
         }
     }
     store_commit(deps, &batch_commitment_key, &commit_acks(&acks));
-    Ok(
-        Response::new().add_event(Event::new(events::packet::BATCH_ACKS).add_attributes([
-            (events::attribute::CHANNEL_ID, channel_id.to_string()),
-            (events::attribute::PACKETS, serialized_packets),
-            (events::attribute::ACKS, serialized_acks),
-        ])),
-    )
+    Ok(Response::new().add_events(events))
 }
 
 fn timeout_packet(

evm/contracts/core/04-channel/IBCPacket.sol

@@ -16,15 +16,23 @@ library IBCPacketLib {
     bytes32 public constant COMMITMENT_NULL = bytes32(uint256(0));
 
     event PacketSend(bytes32 indexed packetHash, IBCPacket packet);
-    event PacketRecv(bytes32 indexed packetHash, address maker, bytes makerMsg);
+    event PacketRecv(
+        bytes32 indexed packetHash, address indexed maker, bytes makerMsg
+    );
     event IntentPacketRecv(
-        bytes32 indexed packetHash, address maker, bytes makerMsg
+        bytes32 indexed packetHash, address indexed maker, bytes makerMsg
     );
     event WriteAck(bytes32 indexed packetHash, bytes acknowledgement);
     event PacketAck(
-        bytes32 indexed packetHash, bytes acknowledgement, address maker
+        bytes32 indexed packetHash, bytes acknowledgement, address indexed maker
+    );
+    event PacketTimeout(bytes32 indexed packetHash, address indexed maker);
+    event BatchedPreviouslySent(
+        bytes32 indexed batchHash, bytes32 indexed packetHash
+    );
+    event BatchedPreviouslyAcked(
+        bytes32 indexed batchHash, bytes32 indexed packetHash
     );
-    event PacketTimeout(bytes32 indexed packetHash, address maker);
 
     function commitAcksMemory(
         bytes[] memory acks
@@ -90,6 +98,7 @@ abstract contract IBCPacketImpl is IBCStore, IIBCPacket {
             revert IBCErrors.ErrNotEnoughPackets();
         }
         uint32 channelId = msg_.packets[0].sourceChannelId;
+        bytes32 batchHash = IBCPacketLib.commitPackets(msg_.packets);
         for (uint256 i = 0; i < l; i++) {
             IBCPacket calldata packet = msg_.packets[i];
             if (i > 0) {
@@ -98,16 +107,17 @@ abstract contract IBCPacketImpl is IBCStore, IIBCPacket {
                 }
             }
             // If the channel mismatch, the commitment will be zero
-            bytes32 commitment = commitments[IBCCommitment
-                .batchPacketsCommitmentKey(IBCPacketLib.commitPacket(packet))];
+            bytes32 packetHash = IBCPacketLib.commitPacket(packet);
+            bytes32 commitment =
+                commitments[IBCCommitment.batchPacketsCommitmentKey(packetHash)];
             // Every packet must have been previously sent to be batched
             if (commitment != IBCPacketLib.COMMITMENT_MAGIC) {
                 revert IBCErrors.ErrPacketCommitmentNotFound();
             }
+            emit IBCPacketLib.BatchedPreviouslySent(batchHash, packetHash);
         }
-        commitments[IBCCommitment.batchPacketsCommitmentKey(
-            IBCPacketLib.commitPackets(msg_.packets)
-        )] = IBCPacketLib.COMMITMENT_MAGIC;
+        commitments[IBCCommitment.batchPacketsCommitmentKey(batchHash)] =
+            IBCPacketLib.COMMITMENT_MAGIC;
     }
 
     function batchAcks(
@@ -119,6 +129,7 @@ abstract contract IBCPacketImpl is IBCStore, IIBCPacket {
             revert IBCErrors.ErrNotEnoughPackets();
         }
         uint32 channelId = msg_.packets[0].destinationChannelId;
+        bytes32 batchHash = IBCPacketLib.commitPackets(msg_.packets);
         for (uint256 i = 0; i < l; i++) {
             IBCPacket calldata packet = msg_.packets[i];
             if (i > 0) {
@@ -128,8 +139,9 @@ abstract contract IBCPacketImpl is IBCStore, IIBCPacket {
             }
             bytes calldata ack = msg_.acks[i];
             // If the channel mismatch, the commitment will be zero.
+            bytes32 packetHash = IBCPacketLib.commitPacket(packet);
             bytes32 commitment = commitments[IBCCommitment
-                .batchReceiptsCommitmentKey(IBCPacketLib.commitPacket(packet))];
+                .batchReceiptsCommitmentKey(packetHash)];
             // Can't batch an empty ack.
             if (
                 commitment == IBCPacketLib.COMMITMENT_NULL
@@ -141,6 +153,7 @@ abstract contract IBCPacketImpl is IBCStore, IIBCPacket {
             if (commitment != IBCPacketLib.commitAck(ack)) {
                 revert IBCErrors.ErrCommittedAckNotPresent();
             }
+            emit IBCPacketLib.BatchedPreviouslyAcked(batchHash, packetHash);
         }
         commitments[IBCCommitment.batchReceiptsCommitmentKey(
             IBCPacketLib.commitPackets(msg_.packets)