Add v2 payload

Author: Bridgerz

crates/sui-bridge/src/abi.rs

@@ -190,8 +190,6 @@ pub struct EthToSuiTokenBridgeV1 {
     pub eth_address: EthAddress,
     pub token_id: u8,
     pub sui_adjusted_amount: u64,
-    #[serde(default)]
-    pub block_timestamp: Option<u64>,
 }
 
 impl TryFrom<&TokensDepositedFilter> for EthToSuiTokenBridgeV1 {
@@ -205,7 +203,6 @@ impl TryFrom<&TokensDepositedFilter> for EthToSuiTokenBridgeV1 {
             eth_address: event.sender_address,
             token_id: event.token_id,
             sui_adjusted_amount: event.sui_adjusted_amount,
-            block_timestamp: None,
         })
     }
 }

crates/sui-framework/packages/bridge/sources/bridge.move

@@ -330,7 +330,7 @@ public fun send_token_v2<T>(
         target_address,
         token_type: token_id,
         amount: token_amount,
-        timestamp: clock.timestamp_ms(),
+        timestamp_ms: clock.timestamp_ms(),
     });
 }
 
@@ -582,14 +582,17 @@ fun claim_token_internal<T>(
     assert!(record.verified_signatures.is_some(), EUnauthorisedClaim);
 
     // extract token message
-    let token_payload = record.message.extract_token_bridge_payload();
     let mut bypass_limiter = false;
-    if (record.message.message_version() == 2) {
-        let timestamp = record.message.extract_token_bridge_payload_v2_timestamp();
+    let mut token_payload;
+    if (record.message.message_version() == 1) {
+        token_payload = record.message.extract_token_bridge_payload();
+    } else if (record.message.message_version() == 2) {
+        let token_payload_v2 = record.message.extract_token_bridge_payload_v2();
+
+        let timestamp = token_payload_v2.timestamp_ms();
         // if token_payload.timestamp is within the last 48 hours, bypass the limiter
-        if (clock.timestamp_ms() < timestamp + 48 * 3600000) {
-            bypass_limiter = true;
-        };
+        bypass_limiter = clock.timestamp_ms() < timestamp + 48 * 3600000;
+        token_payload = token_payload_v2.to_token_payload_v1();
     };
 
     // get owner address

crates/sui-framework/packages/bridge/sources/message.move

@@ -19,6 +19,7 @@ const EInvalidMessageType: u64 = 3;
 const EInvalidEmergencyOpType: u64 = 4;
 const EInvalidPayloadLength: u64 = 5;
 const EMustBeTokenMessage: u64 = 6;
+const EInvalidMessageVersion: u64 = 7;
 
 // Emergency Op types
 const PAUSE: u8 = 0;
@@ -50,6 +51,15 @@ public struct TokenTransferPayload has drop {
     amount: u64,
 }
 
+public struct TokenTransferPayloadV2 has drop {
+    sender_address: vector<u8>,
+    target_chain: u8,
+    target_address: vector<u8>,
+    token_type: u8,
+    amount: u64,
+    timestamp_ms: u64,
+}
+
 public struct EmergencyOp has drop {
     op_type: u8,
 }
@@ -99,6 +109,7 @@ public struct ParsedTokenTransferMessage has drop {
 // Therefore their length can be represented by a single byte.
 // See `create_token_bridge_message` for the actual encoding rule.
 public fun extract_token_bridge_payload(message: &BridgeMessage): TokenTransferPayload {
+    assert!(message.message_version() == 1, EInvalidMessageVersion);
     let mut bcs = bcs::new(message.payload);
     let sender_address = bcs.peel_vec_u8();
     let target_chain = bcs.peel_u8();
@@ -108,12 +119,7 @@ public fun extract_token_bridge_payload(message: &BridgeMessage): TokenTransferP
 
     chain_ids::assert_valid_chain_id(target_chain);
 
-    if (message.message_version() == 2) {
-        let _timestamp = peel_u64_be(&mut bcs);
-        assert!(bcs.into_remainder_bytes().is_empty(), ETrailingBytes);
-    } else {
-        assert!(bcs.into_remainder_bytes().is_empty(), ETrailingBytes);
-    };
+    assert!(bcs.into_remainder_bytes().is_empty(), ETrailingBytes);
 
     TokenTransferPayload {
         sender_address,
@@ -128,18 +134,38 @@ public fun extract_token_bridge_payload(message: &BridgeMessage): TokenTransferP
 // `sender_address` and `target_address` are no longer than 255 bytes.
 // Therefore their length can be represented by a single byte.
 // See `create_token_bridge_message` for the actual encoding rule.
-public fun extract_token_bridge_payload_v2_timestamp(message: &BridgeMessage): u64 {
+public fun extract_token_bridge_payload_v2(message: &BridgeMessage): TokenTransferPayloadV2 {
+    assert!(message.message_version() == 2, EInvalidMessageVersion);
+
     let mut bcs = bcs::new(message.payload);
-    let _sender_address = bcs.peel_vec_u8();
-    let _target_chain = bcs.peel_u8();
-    let _target_address = bcs.peel_vec_u8();
-    let _token_type = bcs.peel_u8();
-    let _amount = peel_u64_be(&mut bcs);
-    let timestamp = peel_u64_be(&mut bcs);
+    let sender_address = bcs.peel_vec_u8();
+    let target_chain = bcs.peel_u8();
+    let target_address = bcs.peel_vec_u8();
+    let token_type = bcs.peel_u8();
+    let amount = peel_u64_be(&mut bcs);
 
+    chain_ids::assert_valid_chain_id(target_chain);
+    let timestamp_ms = peel_u64_be(&mut bcs);
     assert!(bcs.into_remainder_bytes().is_empty(), ETrailingBytes);
 
-    timestamp
+    TokenTransferPayloadV2 {
+        sender_address,
+        target_chain,
+        target_address,
+        token_type,
+        amount,
+        timestamp_ms,
+    }
+}
+
+public fun to_token_payload_v1(self: &TokenTransferPayloadV2): TokenTransferPayload {
+    TokenTransferPayload {
+        sender_address: self.sender_address,
+        target_chain: self.target_chain,
+        target_address: self.target_address,
+        token_type: self.token_type,
+        amount: self.amount,
+    }
 }
 
 /// Emergency op payload is just a single byte
@@ -531,6 +557,10 @@ public fun token_amount(self: &TokenTransferPayload): u64 {
     self.amount
 }
 
+public fun timestamp_ms(self: &TokenTransferPayloadV2): u64 {
+    self.timestamp_ms
+}
+
 // EmergencyOpPayload getters
 public fun emergency_op_type(self: &EmergencyOp): u8 {
     self.op_type