dydx 0.1.1

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
117
118
119
120

#[cfg(any(feature = "faucet", feature = "noble"))]
use anyhow::anyhow as err;
use anyhow::{Error, Result};
use chrono::{TimeDelta, Utc};
#[cfg(feature = "faucet")]
use dydx::faucet::FaucetClient;
#[cfg(feature = "noble")]
use dydx::noble::NobleClient;
use dydx::{
    config::ClientConfig,
    indexer::{ClientId, Height, IndexerClient, PerpetualMarket, Ticker},
    node::{Account, Address, NodeClient, OrderBuilder, OrderId, OrderSide, Subaccount, Wallet},
};

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";

pub enum TestEnv {}

#[allow(dead_code)]
impl TestEnv {
    pub async fn testnet() -> Result<TestnetEnv> {
        TestnetEnv::bootstrap().await
    }

    pub async fn mainnet() -> Result<MainnetEnv> {
        MainnetEnv::bootstrap().await
    }
}

#[allow(dead_code)]
pub struct MainnetEnv {
    pub indexer: IndexerClient,
    pub ticker: Ticker,
}

impl MainnetEnv {
    async fn bootstrap() -> Result<Self> {
        let path = "tests/mainnet.toml";
        let config = ClientConfig::from_file(path).await?;
        let indexer = IndexerClient::new(config.indexer);
        let ticker = Ticker::from("ETH-USD");
        Ok(Self { indexer, ticker })
    }
}

#[allow(dead_code)]
pub struct TestnetEnv {
    pub node: NodeClient,
    pub indexer: IndexerClient,
    #[cfg(feature = "faucet")]
    pub faucet: FaucetClient,
    #[cfg(feature = "noble")]
    pub noble: NobleClient,
    pub wallet: Wallet,
    pub account: Account,
    pub address: Address,
    pub subaccount: Subaccount,
    pub ticker: Ticker,
}

#[allow(dead_code)]
impl TestnetEnv {
    async fn bootstrap() -> Result<Self> {
        let path = "tests/testnet.toml";
        let config = ClientConfig::from_file(path).await?;
        let mut node = NodeClient::connect(config.node).await?;
        let indexer = IndexerClient::new(config.indexer);
        #[cfg(feature = "faucet")]
        let faucet = FaucetClient::new(config.faucet.ok_or_else(|| {
            err!("Configuration file must contain a [faucet] configuration for testing")
        })?);
        #[cfg(feature = "noble")]
        let noble = NobleClient::connect(config.noble.ok_or_else(|| {
            err!("Configuration file must contain a [noble] configuration for testing")
        })?)
        .await?;
        let wallet = Wallet::from_mnemonic(TEST_MNEMONIC)?;
        let account = wallet.account(0, &mut node).await?;
        let ticker = Ticker::from("ETH-USD");
        let address = account.address().clone();
        let subaccount = account.subaccount(0)?;
        Ok(Self {
            node,
            indexer,
            #[cfg(feature = "faucet")]
            faucet,
            #[cfg(feature = "noble")]
            noble,
            wallet,
            account,
            address,
            subaccount,
            ticker,
        })
    }

    pub async fn get_market(&self) -> Result<PerpetualMarket> {
        self.indexer
            .markets()
            .get_perpetual_market(&self.ticker)
            .await
    }

    pub async fn get_height(&self) -> Result<Height> {
        Ok(self.indexer.utility().get_height().await?.height)
    }

    pub async fn spawn_order(&mut self) -> Result<OrderId, Error> {
        let market = self.get_market().await?;
        let subaccount = self.account.subaccount(0)?;
        let (id, order) = OrderBuilder::new(market, subaccount)
            .limit(OrderSide::Buy, 1, 1)
            .until(Utc::now() + TimeDelta::seconds(60))
            .long_term()
            .build(ClientId::random())?;
        let tx_res = self.node.place_order(&mut self.account, order).await;
        self.node.query_transaction_result(tx_res).await?;
        Ok(id)
    }
}