Struct PoolSync 

pub struct PoolSync {
    pub fetchers: HashMap<PoolType, Arc<dyn PoolFetcher>>,
    pub chain: Chain,
    pub rate_limit: u64,
    pub start_block: Option<u64>,
    pub end_block: Option<u64>,
}

The main struct for pool synchronization

Fields

fetchers: HashMap<PoolType, Arc<dyn PoolFetcher>>

Map of pool types to their fetcher implementations

chain: Chain

The chain to sync on

rate_limit: u64

The rate limit of the rpc

start_block: Option<u64>

Optional starting block for synchronization (overrides cache)

end_block: Option<u64>

Optional ending block for synchronization (overrides latest block)

Implementations

impl PoolSync

pub fn builder() -> PoolSyncBuilder

Construct a new builder to configure sync parameters

Examples found in repository

examples/mantle_integration_test.rs (line 12)

async fn main() -> Result<()> {
    // Configure and build the PoolSync instance for Mantle
    let pool_sync = PoolSync::builder()
        .add_pool(PoolType::UniswapV3)      // Uniswap V3 on Mantle
        .chain(Chain::Mantle)               // Target Mantle chain
        .build()?;

    // Synchronize pools
    let (pools, last_synced_block) = pool_sync.sync_pools().await?;

    // Display results (same format as your example)
    println!("=== Mantle Chain Pool Sync Results ===");
    for pool in &pools {
        println!(
            "Pool Address {:?}, Token 0: {:?}, Token 1: {:?}",
            pool.address(),
            pool.token0_name(),
            pool.token1_name()
        );
    }

    println!("Synced {} pools on Mantle chain (Uniswap V3)!", pools.len());
    println!("Last synced block: {}", last_synced_block);

    Ok(())
}

pub async fn sync_pools(&self) -> Result<(Vec<Pool>, u64), PoolSyncError>

Synchronizes all added pools for the specified chain

Examples found in repository

examples/mantle_integration_test.rs (line 18)

async fn main() -> Result<()> {
    // Configure and build the PoolSync instance for Mantle
    let pool_sync = PoolSync::builder()
        .add_pool(PoolType::UniswapV3)      // Uniswap V3 on Mantle
        .chain(Chain::Mantle)               // Target Mantle chain
        .build()?;

    // Synchronize pools
    let (pools, last_synced_block) = pool_sync.sync_pools().await?;

    // Display results (same format as your example)
    println!("=== Mantle Chain Pool Sync Results ===");
    for pool in &pools {
        println!(
            "Pool Address {:?}, Token 0: {:?}, Token 1: {:?}",
            pool.address(),
            pool.token0_name(),
            pool.token1_name()
        );
    }

    println!("Synced {} pools on Mantle chain (Uniswap V3)!", pools.len());
    println!("Last synced block: {}", last_synced_block);

    Ok(())
}