use ethers::prelude::*;
use mev_share_rs::prelude::*;

let auth_wallet = LocalWallet::random();
let provider = Provider::connect("https://rpc.example/api_key");

let client = MevShareClient::new(auth_wallet, provider).await?;

let client = MevShareClient::new_with_chain_id(auth_wallet, provider, 1)?;

use mev_share_rs::prelude::*;

let mut stream = client.subscribe_bundles().await?;
while let Some(event) = stream.next().await {
    let bundle = event?; // upstream any error
    println!("Bundle received: {:?}", bundle);
}

use mev_share_rs::prelude::*;

let pending_tx = client.send_private_transaction(
    SendTransactionParams::builder()
        // a signed `TypedTransaction`
        .tx(tx)
        // drop after 20 blocks
        .max_block_number(current_block + 20)
        .preferences(
            // what to disclose 
            Some(set![
                Hint::Hash, 
                Hint::Calldata, 
                Hint::Logs, 
                Hint::ContractAddress, 
                Hint::FunctionSelector
            ]),
            // to whom
            Some(set![
                Builder::Flashbots, 
            ]),
        )
        .build()
).await?;

let (receipt, block) = pending_tx.inclusion().await?;
println!("Transaction included in block {}", block);

match pending_tx.inclusion().await {
    Err(Error::TransactionTimeout) =>
        println!("the transaction was not included after 25 blocks or params.max_block_number"),
    Err(Error::TransactionReverted) =>
        println!("the transaction was reverted"),
    Ok((receipt, block)) =>
        println!("Transaction included in block {}", block),
}

client
    .send_private_transaction(tx_request)
    .await?
    .inclusion()
    .await?;

let pending_bundle = client.send_private_bundle(
    SendBundleParams::builder()
        .body(vec![
            // a signed `TypedTransaction`
            Signed { tx: tx1, can_revert: false },
            // another signed `TypedTransaction`
            Signed { tx: tx2, can_revert: false },
            // a transaction we found in the mempool
            Tx { hash: tx3 }
        ])
        // drop after 3 blocks
        .inclusion(current_block + 1, Some(current_block + 1 + 3)) 
        // what to disclose to whom
        .privacy(
            // do not share any hints
            None,
            // send only to Flashbots
            Some(set![Builder::Flashbots])
        ),
        )
        .build()
).await?;

let (receipt, block) = pending_bundle.inclusion().await?;
println!("Bundle {:?} included in block {}", pending_bundle.hash, block);

match pending_bundle.inclusion().await {
    Err(Error::BundleTimeout(_hashes , max_block)) =>
        println!("bundle {:?} not included after max block {}", pending_bundle.hash, max_block),
    Err(Error::BundleRevert(receipts)) =>
        println!("bundle {:?} reverted: {:?}", pending_bundle.hash, receipts),
    Err(Error::BundleDiscard(landed_receipts)) =>
        println!("bundle has not been included, but some of the transactions landed: {:?}", landed_receipts),
    Ok((receipts, block)) =>
        println!("Bundle {:?} included in block {}", pending_bundle.hash, block),
}

let (bundle_receipts, included_block) = client
    .send_budnle(bundle_request)
    .await?
    .inclusion()
    .await?;

let simulation = client.simulate_bundle(
    bundle_request.clone(),
    SimulateBundleParams::builder()
        .block(current_block + 1)
        .build()
    ).await?;

// avoid sending a reverting bundle
if !simulation.success { return Err(Error::SimulationFailed(simulation)) }

// simulation success! send the bundle to Flashbots
client.send_bundle(bundle_request).await?.inclusion().await?;