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
121
122
123
124
125
126
127
128
129
130
131

// Copyright (c) Aptos
// SPDX-License-Identifier: Apache-2.0

use crate::streaming_client::Epoch;
use aptos_data_client::{Response, ResponsePayload};
use aptos_types::{
    ledger_info::LedgerInfoWithSignatures,
    state_store::state_value::StateValueChunkWithProof,
    transaction::{TransactionListWithProof, TransactionOutputListWithProof, Version},
};
use std::fmt::{Debug, Formatter};

/// A unique ID used to identify each notification.
pub type NotificationId = u64;

/// A single data notification with an ID and data payload.
#[derive(Clone, Debug)]
pub struct DataNotification {
    pub notification_id: NotificationId,
    pub data_payload: DataPayload,
}

/// A single payload (e.g. chunk) of data delivered to a data listener.
#[allow(clippy::large_enum_variant)]
#[derive(Clone, Debug)]
pub enum DataPayload {
    AccountStatesWithProof(StateValueChunkWithProof),
    ContinuousTransactionOutputsWithProof(LedgerInfoWithSignatures, TransactionOutputListWithProof),
    ContinuousTransactionsWithProof(LedgerInfoWithSignatures, TransactionListWithProof),
    EpochEndingLedgerInfos(Vec<LedgerInfoWithSignatures>),
    EndOfStream,
    TransactionOutputsWithProof(TransactionOutputListWithProof),
    TransactionsWithProof(TransactionListWithProof),
}

/// A request that has been sent to the Aptos data client.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DataClientRequest {
    AccountsWithProof(AccountsWithProofRequest),
    EpochEndingLedgerInfos(EpochEndingLedgerInfosRequest),
    NewTransactionOutputsWithProof(NewTransactionOutputsWithProofRequest),
    NewTransactionsWithProof(NewTransactionsWithProofRequest),
    NumberOfAccounts(NumberOfAccountsRequest),
    TransactionsWithProof(TransactionsWithProofRequest),
    TransactionOutputsWithProof(TransactionOutputsWithProofRequest),
}

impl DataClientRequest {
    /// Returns a summary label for the request
    pub fn get_label(&self) -> &'static str {
        match self {
            Self::AccountsWithProof(_) => "accounts_with_proof",
            Self::EpochEndingLedgerInfos(_) => "epoch_ending_ledger_infos",
            Self::NewTransactionOutputsWithProof(_) => "new_transaction_outputs_with_proof",
            Self::NewTransactionsWithProof(_) => "new_transactions_with_proof",
            Self::NumberOfAccounts(_) => "number_of_accounts",
            Self::TransactionsWithProof(_) => "transactions_with_proof",
            Self::TransactionOutputsWithProof(_) => "transaction_outputs_with_proof",
        }
    }
}

/// A request for fetching account states.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AccountsWithProofRequest {
    pub version: Version,
    pub start_index: u64,
    pub end_index: u64,
}

/// A client request for fetching epoch ending ledger infos.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct EpochEndingLedgerInfosRequest {
    pub start_epoch: Epoch,
    pub end_epoch: Epoch,
}

/// A client request for fetching new transactions with proofs.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct NewTransactionsWithProofRequest {
    pub known_version: Version,
    pub known_epoch: Epoch,
    pub include_events: bool,
}

/// A client request for fetching new transaction outputs with proofs.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct NewTransactionOutputsWithProofRequest {
    pub known_version: Version,
    pub known_epoch: Epoch,
}

/// A client request for fetching the number of accounts at a version.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct NumberOfAccountsRequest {
    pub version: Version,
}

/// A client request for fetching transactions with proofs.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TransactionsWithProofRequest {
    pub start_version: Version,
    pub end_version: Version,
    pub proof_version: Version,
    pub include_events: bool,
}

/// A client request for fetching transaction outputs with proofs.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TransactionOutputsWithProofRequest {
    pub start_version: Version,
    pub end_version: Version,
    pub proof_version: Version,
}

/// A pending client response where data has been requested from the
/// network and will be available in `client_response` when received.
pub struct PendingClientResponse {
    pub client_request: DataClientRequest,
    pub client_response: Option<Result<Response<ResponsePayload>, aptos_data_client::Error>>,
}

impl Debug for PendingClientResponse {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(
            f,
            "Client request: {:?}, client response: {:?}",
            self.client_request, self.client_response
        )
    }
}