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

use std::str::FromStr;

use alloy_json_abi::JsonAbi;
use clickhouse::{fixed_string::FixedString, Row};
use reth_primitives::{Address, B256, U256};
use serde::{Deserialize, Serialize};
use serde_with::{serde_as, DisplayFromStr};

use crate::serde_utils::vec_u256;

#[serde_as]
#[derive(Debug, Row, Serialize, Deserialize)]
pub struct ClickhouseAbis {
    address: String,
    abi:     String,
}

impl From<ClickhouseAbis> for (Address, JsonAbi) {
    fn from(value: ClickhouseAbis) -> Self {
        let address = Address::from_str(&value.address).unwrap();
        let abi = JsonAbi::from_json_str(&value.abi).unwrap();
        (address, abi)
    }
}

#[derive(Row, Deserialize, Debug, Clone, PartialEq)]
pub struct ClickhousePoolReserves {
    pub address:           FixedString,
    pub block_number:      u64,
    pub post_tx_hash:      FixedString,
    #[serde(with = "vec_u256")]
    pub reserves:          Vec<U256>,
    #[serde(rename = "prices.quote_addr")]
    pub prices_quote_addr: Vec<FixedString>,
    #[serde(rename = "prices.base_addr")]
    pub prices_base_addr:  Vec<FixedString>,
    #[serde(rename = "prices.price")]
    pub prices_price:      Vec<f64>,
}

#[serde_as]
#[derive(Debug, Row, Serialize, Deserialize)]
pub struct ClickhouseTokenPrices {
    pub key: (String, String),
    pub val: Vec<ClickhouseExchangePrice>,
}

#[serde_as]
#[derive(Debug, Row, Serialize, Deserialize)]
pub struct ClickhouseExchangePrice {
    pub exchange: String,
    /// (base_address, quote_address)
    /// (timestamp, ask_price, bid_price)
    pub val:      (u64, f64, f64),
}

#[serde_as]
#[derive(Debug, Clone, Serialize, Deserialize, Row)]
pub struct ClickhouseTimesFlow {
    pub block_number:    u64,
    #[serde_as(as = "DisplayFromStr")]
    pub block_hash:      B256,
    pub relay_time:      u64,
    pub p2p_time:        u64,
    #[serde_as(as = "DisplayFromStr")]
    pub proposer_addr:   Address,
    pub proposer_reward: u128,
    #[serde_as(as = "Vec<DisplayFromStr>")]
    pub private_flow:    Vec<B256>,
}