USER
please comment the lines of this code: please comment the lines of this rust code, and explain it: use itertools::Itertools;
use std::sync::Arc;
use crate::{
addresses::WETH_ADDRESS,
bindings::{
flash_bots_uniswap_query::FlashBotsUniswapQuery, i_uniswap_v2_factory::IUniswapV2Factory,
},
};
use ethers::prelude::*;
pub async fn get_markets_by_token<M>(
factory_addresses: Vec<Address>,
flash_query_contract: &FlashBotsUniswapQuery<M>,
client: Arc<M>,
) -> Vec<(H160, Vec<[H160; 3]>)>
where
M: Middleware,
{
let factories: Vec<DexFactory<M>> = factory_addresses
.into_iter()
.map(|address| DexFactory::new(address, flash_query_contract, client.clone()))
.collect();
let weth_address = &WETH_ADDRESS.parse::<Address>().unwrap();
let mut pairs: Vec<[H160; 3]> = vec![];
for factory in factories {
let market_pairs = factory
.get_markets()
.await
.into_iter()
.collect::<Vec<[H160; 3]>>();
for pair in market_pairs {
pairs.push(pair.to_owned());
}
}
let grouped_pairs: Vec<(H160, Vec<[H160; 3]>)> = pairs
.into_iter()
.filter(|pair| {
// println!("pair[0]: {}", pair[0]);
pair[0].eq(weth_address) || pair[1].eq(weth_address)
})
.sorted_by(|pair0, pair1| {
let non_weth0 = if pair0[0].eq(weth_address) {
pair0[1]
} else {
pair0[0]
};
let non_weth1 = if pair1[0].eq(weth_address) {
pair1[1]
} else {
pair1[0]
};
non_weth1.cmp(&non_weth0)
})
.group_by(|pair| {
if pair[0].eq(weth_address) {
pair[1]
} else {
pair[0]
}
})
.into_iter()
.map(|(key, group)| {
let pairs = group.collect::<Vec<[H160; 3]>>();
(key, pairs)
})
.filter(|(_, pairs)| pairs.len() > (1_usize))
.collect::<Vec<(H160, Vec<[H160; 3]>)>>();
grouped_pairs
}
pub struct DexFactory<'a, M> {
factory_contract: IUniswapV2Factory<M>,
flash_query_contract: &'a FlashBotsUniswapQuery<M>,
}
// This should hold Factory of each Dex
// and have a method to query pairs
impl<'a, M> DexFactory<'a, M>
where
M: Middleware,
{
pub fn new(
pair_address: Address,
flash_query_contract: &'a FlashBotsUniswapQuery<M>,
client: Arc<M>,
) -> Self {
let contract = IUniswapV2Factory::new(pair_address, client);
Self {
factory_contract: contract,
flash_query_contract,
}
}
pub async fn get_markets(&self) -> Vec<[H160; 3]> {
let batch_size = U256::from(1000u32);
let mut start = U256::from(0u32);
let batch_limit = 10;
let mut count = 0;
let mut markets: Vec<[H160; 3]> = vec![];
loop {
let stop = start + batch_size;
let pairs = self
.flash_query_contract
.get_pairs_by_index_range(self.factory_contract.address(), start, stop)
.call()
.await
.unwrap();
count += 1;
start = stop;
let pair_length = pairs.len();
markets.extend(pairs);
if pair_length < batch_size.as_usize() || count > batch_limit {
dbg!(markets.len());
break;
}
}
markets
}
}
ASSISTANT
```rust
// Import the necessary external crates and items
use itertools::Itertools;
use std::sync::Arc;
use crate::{
addresses::WETH_ADDRESS,
bindings::{
flash_bots_uniswap_query::FlashBotsUniswapQuery, i_uniswap_v2_factory::IUniswapV2Factory,
},
};
use ethers::prelude::*;
// Define the get_markets_by_token function that returns a Vec of tokens and their associated markets
pub async fn get_markets_by_token<M>(
factory_addresses: Vec<Address>,
flash_query_contract: &FlashBotsUniswapQuery<M>,
client: Arc<M>,
) -> Vec<(H160, Vec<[H160; 3]>)>
where
M: Middleware,
{
// Create DexFactory instances for each factory address
let factories: Vec<DexFactory<M>> = factory_addresses
.into_iter()
.map(|address| DexFactory::new(address, flash_query_contract, client.clone()))
.collect();
// Parse and unwrap the WETH address
let weth_address = &WETH_ADDRESS.parse::<Address>().unwrap();
// Initialize an empty vector for token pairs
let mut pairs: Vec<[H160; 3]> = vec![];
// Iterate through the factories and get the market pairs
for factory in factories {
let market_pairs = factory
.get_markets()
.await
.into_iter()
.collect::<Vec<[H160; 3]>>();
// Add the market pairs to the pairs vector
for pair in market_pairs {
pairs.push(pair.to_owned());
}
}
// Group the token pairs by their associated token and filter out those with less than two pairs
let grouped_pairs: Vec<(H160, Vec<[H160; 3]>)> = pairs
.into_iter()
.filter(|pair| {
pair[0].eq(weth_address) || pair[1].eq(weth_address)
})
.sorted_by(|pair0, pair1| {
let non_weth0 = if pair0[0].eq(weth_address) {
pair0[1]
} else {
pair0[0]
};
let non_weth1 = if pair1[0].eq(weth_address) {
pair1[1]
} else {
pair1[0]
};
non_weth1.cmp(&non_weth0)
})
.group_by(|pair| {
if pair[0].eq(weth_address) {
pair[1]
} else {
pair[0]
}
})
.into_iter()
.map(|(key, group)| {
let pairs = group.collect::<Vec<[H160; 3]>>();
(key, pairs)
})
.filter(|(_, pairs)| pairs.len() > (1_usize))
.collect::<Vec<(H160, Vec<[H160; 3]>)>>();
// Return the grouped pairs
grouped_pairs
}
// Define the DexFactory struct, representing the factory of a DEX
pub struct DexFactory<'a, M> {
factory_contract: IUniswapV2Factory<M>,
flash_query_contract: &'a FlashBotsUniswapQuery<M>,
}
// Implement the methods for the DexFactory
impl<'a, M> DexFactory<'a, M>
where
M: Middleware,
{
// Create a new DexFactory instance, given a pair address, flash query contract, and client
pub fn new(
pair_address: Address,
flash_query_contract: &'a FlashBotsUniswapQuery<M>,
client: Arc<M>,
) -> Self {
// Create a new IUniswapV2Factory instance with the given client
let contract = IUniswapV2Factory::new(pair_address, client);
// Return the DexFactory instance with the initialized factory contract and flash query contract
Self {
factory_contract: contract,
flash_query_contract,
}
}
// Define an async function to get markets from the DexFactory
pub async fn get_markets(&self) -> Vec<[H160; 3]> {
let batch_size = U256::from(1000u32);
let mut start = U256::from(0u32);
let batch_limit = 10;
let mut count = 0;
let mut markets: Vec<[H160; 3]> = vec![];
// Loop through the batches of pairs to create a final list of markets
loop {
let stop = start + batch_size;
// Query the pairs within the current batch from the flash_query_contract
let pairs = self
.flash_query_contract
.get_pairs_by_index_range(self.factory_contract.address(), start, stop)
.call()
.await
.unwrap();
count += 1;
start = stop;
let pair_length = pairs.len();
// Add the pairs to the markets vector
markets.extend(pairs);
// Exit the loop if there are no more pairs or the batch limit is reached
if pair_length < batch_size.as_usize() || count > batch_limit {
dbg!(markets.len());
break;
}
}
// Return the markets
markets
}
}
```
This Rust code defines a `get_markets_by_token` function that takes a list of factory addresses, a flash query contract, and a client as inputs and returns a vector of tokens and their associated markets. The use of `DexFactory` is to interact with Uniswap V2 factory contracts to query related markets.
The code also defines the `DexFactory` struct and methods to interact with Uniswap V2 factory contracts. The `DexFactory` struct holds instances of `IUniswapV2Factory` and `FlashBotsUniswapQuery` contracts. It has an async function `get_markets`, which queries the flash query contract for pairs within a range and returns all the markets it found.