async fn load_utxos(&mut self) -> Result<()> {
    let (next_cursor, has_next_page) = self.loaded_page.unwrap_or((None, true));
    if !has_next_page {
        return Ok(());
    }
    let utxo_page = self
        .client
        .rooch
        .query_utxos(
            UTXOFilterView::owner(self.sender.clone()),
            next_cursor.map(Into::into),
            None,  // No limit specified
            Some(false),
        )
        .await?;  // ❌ No retry on 429 errors

    // ... process UTXOs ...
}

async fn get_total_utxo_value(...) {
    let mut total_value: u64 = 0;
    let mut cursor: Option<IndexerStateIDView> = None;

    loop {  // ✅ Uses loop for pagination
        let page = client
            .rooch
            .query_utxos(
                UTXOFilterView::Owner(address.clone()),
                cursor.map(Into::into),
                Some(MAX_RESULT_LIMIT),
                None,
            )
            .await?;  // But also lacks retry on 429

        // ... accumulate value ...

        if !page.has_next_page {
            break;
        }
        cursor = page.next_cursor;
    }
}

async fn load_utxos(&mut self) -> Result<()> {
    let (next_cursor, has_next_page) = self.loaded_page.unwrap_or((None, true));
    if !has_next_page {
        return Ok(());
    }

    let mut retry_count = 0;
    const MAX_RETRIES: u32 = 5;

    loop {
        let utxo_page = self
            .client
            .rooch
            .query_utxos(
                UTXOFilterView::owner(self.sender.clone()),
                next_cursor.map(Into::into),
                None,
                Some(false),
            )
            .await;

        match utxo_page {
            Ok(page) => {
                debug!("loaded utxos: {:?}", page.data.len());
                let minimal_non_dust = self.sender.script_pubkey().minimal_non_dust();
                for utxo_view in page.data {
                    let utxo = &utxo_view.value;
                    if !self.skip_seal_check && skip_utxo(&utxo_view, minimal_non_dust) {
                        continue;
                    }
                    if utxo_view.metadata.owner_bitcoin_address.is_none() {
                        debug!(
                            "Can not recognize the owner of UTXO {}, metadata: {:?}, skip.",
                            utxo.outpoint(),
                            utxo_view.metadata
                        );
                        continue;
                    }
                    self.candidate_utxos.push_front(utxo_view.into());
                }
                self.loaded_page = Some((page.next_cursor, page.has_next_page));
                return Ok(());
            }
            Err(e) => {
                // Check if it's a 429 error
                let error_msg = e.to_string().to_lowercase();
                if error_msg.contains("429") || error_msg.contains("too many requests") || error_msg.contains("rate limit") {
                    retry_count += 1;
                    if retry_count > MAX_RETRIES {
                        bail!("Too many 429 errors when loading UTXOs, gave up after {} retries", MAX_RETRIES);
                    }

                    // Exponential backoff: wait 2^retry_count seconds
                    let wait_secs = 2u64.pow(retry_count);
                    debug!("Got 429 error, retry {} after waiting {} seconds", retry_count, wait_secs);
                    tokio::time::sleep(tokio::time::Duration::from_secs(wait_secs)).await;
                    continue;
                } else {
                    // Other errors - propagate
                    return Err(e);
                }
            }
        }
    }
}

async fn load_utxos(&mut self) -> Result<()> {
    let (next_cursor, has_next_page) = self.loaded_page.unwrap_or((None, true));
    if !has_next_page {
        return Ok(());
    }

    let utxo_page = self
        .client
        .rooch
        .query_utxos(
            UTXOFilterView::owner(self.sender.clone()),
            next_cursor.map(Into::into),
            None,
            Some(false),
        )
        .await?;

    // Add small delay to avoid rate limiting
    tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;

    // ... rest of the method
}