esplora-client 0.13.0

Asynchronous and blocking clients and types for interacting with Esplora servers over HTTP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// SPDX-License-Identifier: MIT OR Apache-2.0

//! # Tests for Address Methods

#![allow(unused_imports)]
#![cfg(all(feature = "blocking", feature = "async", feature = "tokio"))]

use bitcoin::{opcodes::all, Amount};

use testenv::TestEnv;

mod testenv;

#[tokio::test]
async fn test_get_address_stats() {
    let env = TestEnv::new();
    let (blocking_client, async_client) = env.setup_clients();

    let address = env.get_legacy_address();
    let _txid = env
        .bitcoind_client()
        .send_to_address(&address, Amount::from_sat(1000))
        .unwrap()
        .txid()
        .unwrap();

    let address_stats_blocking = blocking_client.get_address_stats(&address).unwrap();
    let address_stats_async = async_client.get_address_stats(&address).await.unwrap();
    assert_eq!(address_stats_blocking, address_stats_async);
    assert_eq!(address_stats_async.chain_stats.funded_txo_count, 0);

    env.mine_and_wait(1);

    let address_stats_blocking = blocking_client.get_address_stats(&address).unwrap();
    let address_stats_async = async_client.get_address_stats(&address).await.unwrap();
    assert_eq!(address_stats_blocking, address_stats_async);
    assert_eq!(address_stats_async.chain_stats.funded_txo_count, 1);
    assert_eq!(
        address_stats_async.chain_stats.funded_txo_sum,
        Amount::from_sat(1000)
    );
}

#[tokio::test]
async fn test_get_address_txs() {
    let env = TestEnv::new();
    let (blocking_client, async_client) = env.setup_clients();

    let address = env.get_legacy_address();
    let txid = env
        .bitcoind_client()
        .send_to_address(&address, Amount::from_sat(1000))
        .unwrap()
        .txid()
        .unwrap();
    env.mine_and_wait(1);

    let address_txs_blocking = blocking_client.get_address_txs(&address, None).unwrap();
    let address_txs_async = async_client.get_address_txs(&address, None).await.unwrap();

    assert_eq!(address_txs_blocking, address_txs_async);
    assert_eq!(address_txs_async[0].txid, txid);
}

#[tokio::test]
async fn test_get_address_utxos() {
    let env = TestEnv::new();
    let (blocking_client, async_client) = env.setup_clients();

    let address = env.get_legacy_address();
    let _txid = env
        .bitcoind_client()
        .send_to_address(&address, Amount::from_sat(21000))
        .unwrap()
        .txid()
        .unwrap();

    env.mine_and_wait(1);

    let address_utxos_blocking = blocking_client.get_address_utxos(&address).unwrap();
    let address_utxos_async = async_client.get_address_utxos(&address).await.unwrap();

    assert_ne!(address_utxos_blocking.len(), 0);
    assert_ne!(address_utxos_async.len(), 0);
    assert_eq!(address_utxos_blocking, address_utxos_async);
}