arbiter-core 0.11.0

Allowing smart contract developers to do simulation driven development via an EVM emulator
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

use std::path::Path;

use arbiter_core::{
    errors::ArbiterCoreError,
    events::{Logger, OutputFileType},
};
use ethers::types::U256 as eU256;
use serde::Serialize;
include!("common.rs");

#[derive(Serialize, Clone)]
struct MockMetadata {
    pub name: String,
}

async fn generate_events(
    arbx: ArbiterToken<ArbiterMiddleware>,
    arby: ArbiterToken<ArbiterMiddleware>,
    lex: LiquidExchange<ArbiterMiddleware>,
    client: Arc<ArbiterMiddleware>,
) -> Result<(), ArbiterCoreError> {
    for _ in 0..2 {
        arbx.approve(client.address(), eU256::from(1))
            .send()
            .await
            .unwrap()
            .await?;
        arby.approve(client.address(), eU256::from(1))
            .send()
            .await
            .unwrap()
            .await?;
        lex.set_price(eU256::from(10u128.pow(18)))
            .send()
            .await
            .unwrap()
            .await?;
    }
    Ok(())
}

#[tokio::test]
async fn data_capture() {
    //
    let (env, client) = startup();
    let (arbx, arby, lex) = deploy_liquid_exchange(client.clone()).await;
    println!("Deployed contracts");

    // default_listener
    let logger_task = Logger::builder()
        .with_event(arbx.events(), "arbx")
        .with_event(arby.events(), "arby")
        .with_event(lex.events(), "lex")
        .run()
        .unwrap();

    let metadata = MockMetadata {
        name: "test".to_string(),
    };

    Logger::builder()
        .with_event(arbx.events(), "arbx")
        .with_event(arby.events(), "arby")
        .with_event(lex.events(), "lex")
        .metadata(metadata)
        .unwrap()
        .run()
        .unwrap();

    Logger::builder()
        .with_event(arbx.events(), "arbx")
        .with_event(arby.events(), "arby")
        .with_event(lex.events(), "lex")
        .file_type(OutputFileType::CSV)
        .run()
        .unwrap();

    Logger::builder()
        .with_event(arbx.events(), "arbx")
        .with_event(arby.events(), "arby")
        .with_event(lex.events(), "lex")
        .file_type(OutputFileType::Parquet)
        .run()
        .unwrap();

    generate_events(arbx, arby, lex, client.clone())
        .await
        .unwrap_or_else(|e| {
            panic!("Error generating events: {}", e);
        });

    let _ = env.stop();

    logger_task.await.unwrap();
    std::thread::sleep(std::time::Duration::from_secs(1));
    assert!(Path::new("./data/output.csv").exists());
    assert!(Path::new("./data/output.parquet").exists());
    assert!(Path::new("./data/output.json").exists());
    std::fs::remove_dir_all("./data").unwrap();
}