use lwk_wollet::{ElectrumClient, ElectrumUrl};

let electrum_url = ElectrumUrl::new("blockstream.info:995", true, true)?;
let mut client = ElectrumClient::new(&electrum_url)?;

# Create electrum client with custom URL
client = ElectrumClient("blockstream.info:995", tls=True, validate_domain=True)

# Or use the default electrum client for the network
default_client = Network.mainnet().default_electrum_client()

// Create electrum client with custom URL
electrumClient, err := lwk.NewElectrumClient("blockstream.info:995", true, true)
if err != nil {
    log.Fatal(err)
}

// Or use the default electrum client for the network
defaultClient, err := lwk.NetworkMainnet().DefaultElectrumClient()
if err != nil {
    log.Fatal(err)
}

use lwk_wollet::clients::blocking::EsploraClient;

let esplora_url = "https://blockstream.info/liquid/api";
let mut client = EsploraClient::new(esplora_url, Network::Liquid)?;

url = "https://blockstream.info/liquid/api"
client = EsploraClient(url, Network.mainnet())

const url_esplora = "https://blockstream.info/liquid/api";
const esplora_client = new lwk.EsploraClient(lwk.Network.mainnet(), url_esplora, true, 4, false);

esploraClient, err := lwk.NewEsploraClient("https://blockstream.info/liquid/api", lwk.NetworkMainnet())
if err != nil {
    log.Fatal(err)
}

let waterfalls_url = "https://waterfalls.liquidwebwallet.org/liquid/api";
let mut client = WaterfallsClientBuilder::new(waterfalls_url, Network::Liquid).build()?;

url = "https://waterfalls.liquidwebwallet.org/liquid/api"
client = WaterfallsClient(url, Network.mainnet())

const url_waterfalls = "https://waterfalls.liquidwebwallet.org/liquid/api";
const waterfalls_client = new lwk.WaterfallsClient(lwk.Network.mainnet(), url_waterfalls);

waterfallsClient, err := lwk.NewWaterfallsClient("https://waterfalls.liquidwebwallet.org/liquid/api", lwk.NetworkMainnet())
if err != nil {
    log.Fatal(err)
}

let mut client = ElectrumClient::new(&primary_url)?;

let update = match client.full_scan(&wollet) {
    Ok(x) => Ok(x),
    Err(_e) => {
        // Falling into a retryable error, making a request with the fallback client
        let mut fallback_client = ElectrumClient::new(&fallback_url)?;
        fallback_client.full_scan(&wollet)
    }
}?;

if let Some(update) = update {
    wollet.apply_update(update)?;
}

client = ElectrumClient.from_url(primary_url)

try:
    update = client.full_scan(wollet)

except Exception:
    # Falling into a retryable error, making a request with the fallback client
    fallback_client = ElectrumClient.from_url(fallback_url)
    update = fallback_client.full_scan(wollet)

wollet.apply_update(update)

const client = new lwk.EsploraClient(network, primary_url, waterfalls, concurrency, utxo_only);

let update;

try {
    update = await client.fullScan(wollet);
} catch (error) {
    // Falling into a retryable error, making a request with the fallback client
    const fallbackClient = new lwk.EsploraClient(network, fallback_url, waterfalls, concurrency, utxo_only);
    update = await fallbackClient.fullScan(wollet);
}

if (update) {
    wollet.applyUpdate(update);
}

client, err := lwk.ElectrumClientFromUrl(primaryUrl)
if err != nil {
    log.Fatal(err)
}

update, err := client.FullScan(wollet)
if err != nil {
    // Falling into a retryable error, making a request with the fallback client
    fallbackClient, err := lwk.ElectrumClientFromUrl(fallbackUrl)
    if err != nil {
        log.Fatal(err)
    }

    update, err = fallbackClient.FullScan(wollet)
    if err != nil {
        log.Fatal(err)
    }
}

if update != nil {
    if err := wollet.ApplyUpdate(*update); err != nil {
        log.Fatal(err)
    }
}

let mut client = clients::asyncr::EsploraClientBuilder::new(base_url, network)
    .token_provider(clients::TokenProvider::Blockstream {
        url: login_url.to_string(),
        client_id: client_id.to_string(),
        client_secret: client_secret.to_string(),
    })
    .build()
    .unwrap();

builder = EsploraClientBuilder(
    base_url=base_url,
    network=network,
    token_provider=TokenProvider.BLOCKSTREAM(
        url=login_url,
        client_id=client_id,
        client_secret=client_secret,
    ),
)
client = EsploraClient.from_builder(builder)

var tpBlockstream lwk.TokenProvider = lwk.TokenProviderBlockstream{
    Url:          loginUrl,
    ClientId:     clientId,
    ClientSecret: clientSecret,
}

builder := lwk.EsploraClientBuilder{
    BaseUrl:       baseUrl,
    Network:       network,
    TokenProvider: &tpBlockstream,
}
client, err := lwk.EsploraClientFromBuilder(builder)

let client = clients::WaterfallsClientBuilder::new(base_url, network)
    .token_provider(clients::TokenProvider::Blockstream {
        url: login_url.to_string(),
        client_id: client_id.to_string(),
        client_secret: client_secret.to_string(),
    })
    .build_blocking()
    .unwrap();

// The token provider needs the `electrum_oidc` cargo feature.
let mut client = ElectrumClientBuilder::new(url)
    .token_provider(clients::TokenProvider::Blockstream {
        url: login_url.to_string(),
        client_id: client_id.to_string(),
        client_secret: client_secret.to_string(),
    })
    .build()
    .unwrap();

builder = ElectrumClientBuilder(
    url=url,
    token_provider=TokenProvider.BLOCKSTREAM(
        url=login_url, client_id=client_id, client_secret=client_secret
    ),
    timeout=30,
)
# Building connects to the proxy and mints the OAuth token (the connection's first
# message carries it); the client is then ready for authenticated calls.
client = ElectrumClient.from_builder(builder)
tip = client.tip()