dydx 0.1.0

dYdX v4 asynchronous client.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use anyhow::Result;

#[cfg(feature = "noble")]
mod noble_transfer_example {
    use super::*;
    use anyhow::{anyhow as err, Error};
    use dydx::config::ClientConfig;
    use dydx::indexer::Token;
    use dydx::noble::{NobleClient, NobleUsdc};
    use dydx::node::{NodeClient, Wallet};
    use tokio::time::{sleep, Duration};

    const TEST_MNEMONIC: &str = "mirror actor skill push coach wait confirm orchard lunch mobile athlete gossip awake miracle matter bus reopen team ladder lazy list timber render wait";
    const DYDX_SOURCE_CHANNEL: &str = "channel-0";
    const NOBLE_SOURCE_CHANNEL: &str = "channel-33";

    pub struct Bridger {
        wallet: Wallet,
        noble: NobleClient,
        node: NodeClient,
    }

    impl Bridger {
        pub async fn connect() -> Result<Self> {
            let config = ClientConfig::from_file("client/tests/testnet.toml").await?;
            let noble = NobleClient::connect(
                config
                    .noble
                    .ok_or_else(|| err!("Config file must contain a [noble] config!"))?,
            )
            .await?;
            let node = NodeClient::connect(config.node).await?;
            let wallet = Wallet::from_mnemonic(TEST_MNEMONIC)?;
            Ok(Self {
                noble,
                wallet,
                node,
            })
        }
    }

    #[tokio::main]
    pub async fn run() -> Result<()> {
        tracing_subscriber::fmt().try_init().map_err(Error::msg)?;
        let mut bridger = Bridger::connect().await?;

        let mut account_dydx = bridger.wallet.account_offline(0)?;
        let mut account_noble = bridger.wallet.noble().account_offline(0)?;

        let address_dydx = account_dydx.address().clone();
        let address_noble = account_noble.address().clone();

        tracing::info!(
            "Before transfer balance: {:?}",
            bridger
                .noble
                .get_account_balances(address_noble.clone())
                .await?
        );
        let tx_hash = bridger
            .node
            .send_token_ibc(
                &mut account_dydx,
                address_dydx.clone(),
                address_noble.clone(),
                Token::Usdc(1.into()),
                DYDX_SOURCE_CHANNEL.into(),
            )
            .await?;
        tracing::info!("dYdX -> Noble Tx hash: {tx_hash}");

        sleep(Duration::from_secs(30)).await;

        tracing::info!(
            "After transfer balance: {:?}",
            bridger
                .noble
                .get_account_balances(address_noble.clone())
                .await?
        );

        let tx_hash = bridger
            .noble
            .send_token_ibc(
                &mut account_noble,
                address_noble.clone(),
                address_dydx,
                NobleUsdc::from(1),
                NOBLE_SOURCE_CHANNEL.into(),
            )
            .await?;
        tracing::info!("Noble -> dYdX Tx hash: {tx_hash}");

        sleep(Duration::from_secs(30)).await;

        tracing::info!(
            "Undo transfer balance: {:?}",
            bridger
                .noble
                .get_account_balances(address_noble.clone())
                .await?
        );

        Ok(())
    }
}

#[cfg(feature = "noble")]
fn main() -> Result<()> {
    noble_transfer_example::run()
}

#[cfg(not(feature = "noble"))]
fn main() {
    eprintln!("Feature 'noble' must be enabled to run this example!")
}