Index V2 bridge events with message_timestamp_ms (#25421)

## Summary

Adds V2 bridge event indexing and a new `message_timestamp_ms` column so
the bridge frontend can determine limiter-bypass eligibility.

### Problem

V2 bridge transfers embed a timestamp in the message payload. Transfers
older than 48 hours bypass the rate limiter. The indexer wasn't
capturing this timestamp, so the frontend had no way to show bypass
eligibility.

### Changes

**Database migration**
- Adds `message_timestamp_ms BIGINT` (nullable) to `token_transfer_data`
- `NULL` for V1 transfers, populated for V2 transfers
- Safe metadata-only `ALTER TABLE ADD COLUMN` (no table rewrite, no long
locks)

**ETH indexer** (`sui-bridge-indexer`)
- `TokensDeposited` (V1): sets `message_timestamp_ms = NULL`
- `TokensDepositedV2`: extracts `timestampSeconds` from the event,
converts to ms

**Sui alt indexer** (`sui-bridge-indexer-alt`)
- `token_transfer_data_handler`: now handles both `TokenDepositedEvent`
(V1) and `TokenDepositedEventV2`
- `token_transfer_handler`: now handles `TokenDepositedEventV2` with
appropriate metrics

**Frontend usage**
```
IF message_timestamp_ms IS NOT NULL
   AND now() - message_timestamp_ms > 48 hours
THEN transfer is limiter-bypass eligible
```

### Testing
- All three crates (`sui-bridge-schema`, `sui-bridge-indexer`,
`sui-bridge-indexer-alt`) compile cleanly with no warnings

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Bridgerz

Cargo.lock

@@ -18,6 +18,7 @@ const COMMITTEE: &IdentStr = ident_str!("committee");
 const TREASURY: &IdentStr = ident_str!("treasury");
 
 const TOKEN_DEPOSITED_EVENT: &IdentStr = ident_str!("TokenDepositedEvent");
+const TOKEN_DEPOSITED_EVENT_V2: &IdentStr = ident_str!("TokenDepositedEventV2");
 const TOKEN_TRANSFER_APPROVED: &IdentStr = ident_str!("TokenTransferApproved");
 const TOKEN_TRANSFER_CLAIMED: &IdentStr = ident_str!("TokenTransferClaimed");
 

crates/sui-bridge-indexer-alt/src/handlers/mod.rs

@@ -1,12 +1,12 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
-use crate::handlers::{BRIDGE, TOKEN_DEPOSITED_EVENT, is_bridge_txn};
+use crate::handlers::{BRIDGE, TOKEN_DEPOSITED_EVENT, TOKEN_DEPOSITED_EVENT_V2, is_bridge_txn};
 use crate::struct_tag;
 use async_trait::async_trait;
 use diesel_async::RunQueryDsl;
 use move_core_types::language_storage::StructTag;
 use std::sync::Arc;
-use sui_bridge::events::MoveTokenDepositedEvent;
+use sui_bridge::events::{MoveTokenDepositedEvent, MoveTokenDepositedEventV2};
 use sui_bridge_schema::models::TokenTransferData;
 use sui_bridge_schema::schema::token_transfer_data;
 use sui_indexer_alt_framework::pipeline::Processor;
@@ -18,12 +18,14 @@ use tracing::info;
 
 pub struct TokenTransferDataHandler {
     deposited_event_type: StructTag,
+    deposited_event_v2_type: StructTag,
 }
 
 impl Default for TokenTransferDataHandler {
     fn default() -> Self {
         Self {
             deposited_event_type: struct_tag!(BRIDGE_ADDRESS, BRIDGE, TOKEN_DEPOSITED_EVENT),
+            deposited_event_v2_type: struct_tag!(BRIDGE_ADDRESS, BRIDGE, TOKEN_DEPOSITED_EVENT_V2),
         }
     }
 }
@@ -47,24 +49,41 @@ impl Processor for TokenTransferDataHandler {
                 continue;
             }
             for ev in tx.events.iter().flat_map(|e| &e.data) {
-                if self.deposited_event_type != ev.type_ {
-                    continue;
+                if self.deposited_event_type == ev.type_ {
+                    info!(?ev, "Observed Sui Deposit");
+                    let event: MoveTokenDepositedEvent = bcs::from_bytes(&ev.contents)?;
+                    results.push(TokenTransferData {
+                        chain_id: event.source_chain as i32,
+                        nonce: event.seq_num as i64,
+                        block_height,
+                        timestamp_ms,
+                        destination_chain: event.target_chain as i32,
+                        sender_address: event.sender_address.clone(),
+                        recipient_address: event.target_address.clone(),
+                        token_id: event.token_type as i32,
+                        amount: event.amount_sui_adjusted as i64,
+                        is_finalized: true,
+                        txn_hash: tx.transaction.digest().inner().to_vec(),
+                        message_timestamp_ms: None,
+                    });
+                } else if self.deposited_event_v2_type == ev.type_ {
+                    info!(?ev, "Observed Sui V2 Deposit");
+                    let event: MoveTokenDepositedEventV2 = bcs::from_bytes(&ev.contents)?;
+                    results.push(TokenTransferData {
+                        chain_id: event.source_chain as i32,
+                        nonce: event.seq_num as i64,
+                        block_height,
+                        timestamp_ms,
+                        destination_chain: event.target_chain as i32,
+                        sender_address: event.sender_address.clone(),
+                        recipient_address: event.target_address.clone(),
+                        token_id: event.token_type as i32,
+                        amount: event.amount_sui_adjusted as i64,
+                        is_finalized: true,
+                        txn_hash: tx.transaction.digest().inner().to_vec(),
+                        message_timestamp_ms: Some(event.timestamp_ms as i64),
+                    });
                 }
-                info!(?ev, "Observed Sui Deposit");
-                let event: MoveTokenDepositedEvent = bcs::from_bytes(&ev.contents)?;
-                results.push(TokenTransferData {
-                    chain_id: event.source_chain as i32,
-                    nonce: event.seq_num as i64,
-                    block_height,
-                    timestamp_ms,
-                    destination_chain: event.target_chain as i32,
-                    sender_address: event.sender_address.clone(),
-                    recipient_address: event.target_address.clone(),
-                    token_id: event.token_type as i32,
-                    amount: event.amount_sui_adjusted as i64,
-                    is_finalized: true,
-                    txn_hash: tx.transaction.digest().inner().to_vec(),
-                });
             }
         }
         Ok(results)

crates/sui-bridge-indexer-alt/src/handlers/token_transfer_data_handler.rs

@@ -1,7 +1,8 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 use crate::handlers::{
-    BRIDGE, TOKEN_DEPOSITED_EVENT, TOKEN_TRANSFER_APPROVED, TOKEN_TRANSFER_CLAIMED, is_bridge_txn,
+    BRIDGE, TOKEN_DEPOSITED_EVENT, TOKEN_DEPOSITED_EVENT_V2, TOKEN_TRANSFER_APPROVED,
+    TOKEN_TRANSFER_CLAIMED, is_bridge_txn,
 };
 use crate::metrics::BridgeIndexerMetrics;
 use crate::struct_tag;
@@ -10,7 +11,8 @@ use diesel_async::RunQueryDsl;
 use move_core_types::language_storage::StructTag;
 use std::sync::Arc;
 use sui_bridge::events::{
-    MoveTokenDepositedEvent, MoveTokenTransferApproved, MoveTokenTransferClaimed,
+    MoveTokenDepositedEvent, MoveTokenDepositedEventV2, MoveTokenTransferApproved,
+    MoveTokenTransferClaimed,
 };
 use sui_bridge_schema::models::{BridgeDataSource, TokenTransfer, TokenTransferStatus};
 use sui_bridge_schema::schema::token_transfer;
@@ -25,6 +27,7 @@ use tracing::info;
 
 pub struct TokenTransferHandler {
     deposited_event_type: StructTag,
+    deposited_event_v2_type: StructTag,
     approved_event_type: StructTag,
     claimed_event_type: StructTag,
     metrics: Arc<BridgeIndexerMetrics>,
@@ -34,6 +37,7 @@ impl TokenTransferHandler {
     pub fn new(metrics: Arc<BridgeIndexerMetrics>) -> Self {
         Self {
             deposited_event_type: struct_tag!(BRIDGE_ADDRESS, BRIDGE, TOKEN_DEPOSITED_EVENT),
+            deposited_event_v2_type: struct_tag!(BRIDGE_ADDRESS, BRIDGE, TOKEN_DEPOSITED_EVENT_V2),
             approved_event_type: struct_tag!(BRIDGE_ADDRESS, BRIDGE, TOKEN_TRANSFER_APPROVED),
             claimed_event_type: struct_tag!(BRIDGE_ADDRESS, BRIDGE, TOKEN_TRANSFER_CLAIMED),
             metrics,
@@ -92,6 +96,29 @@ impl Processor for TokenTransferHandler {
                         .with_label_values(&["sui_to_eth", "true"])
                         .inc_by(tx.effects.gas_cost_summary().net_gas_usage() as u64);
 
+                    (event.source_chain, event.seq_num)
+                } else if self.deposited_event_v2_type == ev.type_ {
+                    info!("Observed Sui V2 Deposit {:?}", ev);
+                    let event: MoveTokenDepositedEventV2 = bcs::from_bytes(&ev.contents)?;
+
+                    // Bridge-specific metrics for V2 token deposits
+                    self.metrics
+                        .bridge_events_total
+                        .with_label_values(&["token_deposited_v2", "sui"])
+                        .inc();
+                    self.metrics
+                        .token_transfers_total
+                        .with_label_values(&[
+                            "sui_to_eth",
+                            "deposited",
+                            &event.token_type.to_string(),
+                        ])
+                        .inc();
+                    self.metrics
+                        .token_transfer_gas_used
+                        .with_label_values(&["sui_to_eth", "true"])
+                        .inc_by(tx.effects.gas_cost_summary().net_gas_usage() as u64);
+
                     (event.source_chain, event.seq_num)
                 } else if self.approved_event_type == ev.type_ {
                     info!("Observed Sui Approval {:?}", ev);

crates/sui-bridge-indexer-alt/src/handlers/token_transfer_handler.rs

@@ -35,6 +35,7 @@ tracing.workspace = true
 backoff.workspace = true
 sui-config.workspace = true
 tempfile.workspace = true
+rustls.workspace = true
 
 [dev-dependencies]
 sui-test-transaction-builder.workspace = true

crates/sui-bridge-indexer/Cargo.toml

@@ -530,16 +530,21 @@ impl DataMapper<RawEthData, ProcessedTxnData> for EthDataMapper {
                             token_id: bridge_event.tokenID,
                             amount: bridge_event.suiAdjustedAmount,
                             is_finalized,
+                            message_timestamp_ms: None,
                         }),
                     }));
                 }
                 EthSuiBridgeEvents::TokensDepositedV2(bridge_event) => {
                     info!(
-                        "Observed Eth Deposit at block: {}, tx_hash: {}",
+                        "Observed Eth V2 Deposit at block: {}, tx_hash: {}",
                         log.block_number(),
                         log.tx_hash
                     );
                     self.metrics.total_eth_token_deposited.inc();
+                    // V2 event carries `timestampSeconds` from the EVM contract.
+                    // Convert seconds → milliseconds so the frontend can compare
+                    // against the 48-hour limiter-bypass window.
+                    let msg_timestamp_ms = bridge_event.timestampSeconds.to::<u64>() * 1000;
                     processed_txn_data.push(ProcessedTxnData::TokenTransfer(TokenTransfer {
                         chain_id: bridge_event.sourceChainID,
                         nonce: bridge_event.nonce,
@@ -558,6 +563,7 @@ impl DataMapper<RawEthData, ProcessedTxnData> for EthDataMapper {
                             token_id: bridge_event.tokenID,
                             amount: bridge_event.suiAdjustedAmount,
                             is_finalized,
+                            message_timestamp_ms: Some(msg_timestamp_ms),
                         }),
                     }));
                 }

crates/sui-bridge-indexer/src/eth_bridge_indexer.rs

@@ -82,6 +82,9 @@ pub struct TokenTransferData {
     token_id: u8,
     amount: u64,
     is_finalized: bool,
+    /// For V2 transfers, the timestamp (in ms) from the bridge message payload.
+    /// `None` for V1 transfers.
+    message_timestamp_ms: Option<u64>,
 }
 
 impl TokenTransfer {
@@ -113,6 +116,7 @@ impl TokenTransfer {
             token_id: data.token_id as i32,
             amount: data.amount as i64,
             is_finalized: data.is_finalized,
+            message_timestamp_ms: data.message_timestamp_ms.map(|ts| ts as i64),
         })
     }
 }

crates/sui-bridge-indexer/src/lib.rs

@@ -45,6 +45,10 @@ struct Args {
 
 #[tokio::main]
 async fn main() -> Result<()> {
+    rustls::crypto::ring::default_provider()
+        .install_default()
+        .expect("Failed to install CryptoProvider");
+
     let _guard = telemetry_subscribers::TelemetryConfig::new()
         .with_env()
         .init();

crates/sui-bridge-indexer/src/main.rs

@@ -133,6 +133,9 @@ impl Persistent<ProcessedTxnData> for PgBridgePersistent {
                                                 .eq(excluded(token_transfer_data::amount)),
                                             token_transfer_data::is_finalized
                                                 .eq(excluded(token_transfer_data::is_finalized)),
+                                            token_transfer_data::message_timestamp_ms.eq(excluded(
+                                                token_transfer_data::message_timestamp_ms,
+                                            )),
                                         ))
                                         .filter(token_transfer_data::is_finalized.eq(false))
                                         .execute(conn)

crates/sui-bridge-indexer/src/storage.rs

@@ -0,0 +1 @@
+ALTER TABLE token_transfer_data DROP COLUMN message_timestamp_ms;