fn test_list_owned_txouts() {
    // Create localchain of 10 blocks.

    let local_chain = local_chain![
        (0, h!("Block 0")),
        (1, h!("Block 1")),
        (2, h!("Block 2")),
        (3, h!("Block 3"))
    ];

    let desc_1 : &str = "tr(tprv8ZgxMBicQKsPd3krDUsBAmtnRsK3rb8u5yi1zhQgMhF1tR8MW7xfE4rnrbbsrbPR52e7rKapu6ztw1jXveJSCGHEriUGZV7mCe88duLp5pj/86'/1'/0'/0/*)";

    let (desc_1, _) = Descriptor::parse_descriptor(&Secp256k1::signing_only(), desc_1).unwrap();

    let desc_2 : &str = "tr(tprv8ZgxMBicQKsPd3krDUsBAmtnRsK3rb8u5yi1zhQgMhF1tR8MW7xfE4rnrbbsrbPR52e7rKapu6ztw1jXveJSCGHEriUGZV7mCe88duLp5pj/86'/1'/0'/1/*)";

    let (desc_2, _) = Descriptor::parse_descriptor(&Secp256k1::signing_only(), desc_2).unwrap();

    // Have two descriptor for two keychains.

    let mut graph = IndexedTxGraph::<BlockId, KeychainTxOutIndex<String>>::default();

    graph.index.add_keychain("keychain_1".into(), desc_1);
    graph.index.add_keychain("keychain_2".into(), desc_2);

    graph.index.set_lookahead_for_all(10);

    let spk1 = {
        let ((_, spk1), _) = graph.index.reveal_next_spk(&"keychain_1".to_string());
        spk1.clone()
    };

    let spk2 = {
        let ((_, spk2), _) = graph.index.reveal_next_spk(&"keychain_2".to_string());
        spk2.clone()
    };

    let spk3 = {
        let ((_, spk1), _) = graph.index.reveal_next_spk(&"keychain_1".to_string());
        spk1.clone()
    };

    let spk4 = {
        let ((_, spk2), _) = graph.index.reveal_next_spk(&"keychain_2".to_string());
        spk2.clone()
    };

    // tx1 spends to desc1

    let tx1 = Transaction {
        output: vec![TxOut {
            value: 10000,
            script_pubkey: spk1,
        }],
        ..common::new_tx(0)
    };

    let tx2 = Transaction {
        output: vec![TxOut {
            value: 20000,
            script_pubkey: spk2,
        }],
        ..common::new_tx(0)
    };

    let tx3 = common::new_tx(0);

    let tx4 = Transaction {
        input: vec![TxIn {
            previous_output: OutPoint::new(tx1.txid(), 0),
            ..Default::default()
        }],
        output: vec![TxOut {
            value: 40000,
            script_pubkey: spk3,
        }],
        ..common::new_tx(0)
    };

    let tx5 = Transaction {
        input: vec![TxIn {
            previous_output: OutPoint::new(tx2.txid(), 0),
            ..Default::default()
        }],
        output: vec![TxOut {
            value: 50000,
            script_pubkey: spk4,
        }],
        ..common::new_tx(0)
    };

    let mut tx_iterator = Vec::new();

    tx_iterator.push((
        &tx1,
        vec![local_chain.get_block(0).expect("block expected")],
    ));
    tx_iterator.push((
        &tx2,
        vec![local_chain.get_block(1).expect("block expected")],
    ));
    tx_iterator.push((&tx3, vec![]));
    tx_iterator.push((
        &tx4,
        vec![local_chain.get_block(2).expect("block expected")],
    ));
    tx_iterator.push((&tx5, vec![]));

    //let x = [tx1, tx2, tx4, tx5].iter().enumerate().map(|(i, tx)| (&tx, [local_chain.get_block(0).unwrap()])).chain([tx3, tx5].iter().map(|tx| (&tx, None)))

    let y = graph.insert_relevant_txs(
        [tx1, tx2, tx4]
            .iter()
            .enumerate()
            .map(|(i, tx)| (tx, [local_chain.get_block(i as u32).unwrap()])),
        None,
    );

    let x = graph.insert_relevant_txs([tx3, tx5].iter().map(|tx| (tx, None)), None);

    println!("Relevant insertion addition: {:#?}", x);
    // tx2 spends to desc2

    // Create tx1, tx2, tx3. Tx1 and 2 spends to owned spk and confirmed at
    // height 3 and 5 respectively.

    // create tx4 which is unrelated.

    // create tx5 which spends tx1 and is confirmed.

    // create tx6 which spends tx2 and is unconfirmed.

    // Insert relevant txs into graph.

    // Use the chain to find onchain utxos,

    let tip = local_chain.tip().expect("tip expected");

    let txouts = graph
        .list_owned_txouts(&local_chain, tip)
        .collect::<Vec<_>>();

    let utxos = graph
        .list_owned_unspents(&local_chain, tip)
        .collect::<Vec<_>>();

    let balance = graph.balance(&local_chain, tip, |_| true);

    // list owned txouts

    // list onwed unspents

    // list owned balance.

    println!("owned txouts : {:#?}", txouts);

    println!("Owned utxos: {:#?}", utxos);

    println!(" Balance : {:#?}", balance);