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
132

use std::path::PathBuf;

use flex_error::{define_error, TraceError};
use itertools::Itertools;
use tokio::task::JoinError;
use tokio::time::error::Elapsed;

define_error! {
    RegistryError {

        GrpcEndpointParseError
            { grpc: String }
            [ TraceError<http::Error> ]
            |e| { format_args!("Unable to parse gRPC endpoint for: {}", e.grpc) },

        JoinError
            { task: String }
            [ TraceError<JoinError> ]
            |e| { format_args!("Error when joining task: {}", e.task) },

        JsonParseError
            { chain_name: String }
            [ TraceError <serde_json::Error> ]
            |e| { format_args!("Error when parsing JSON for chain {}", e.chain_name) },

        NoAssetFound
            { chain_name: String }
            |e| { format_args!("No asset found for chain: {}", e.chain_name) },

        NoHealthyGrpc
            { chain: String }
            |e| { format_args!("No healthy gRPC found for chain: {}", e.chain) },

        NoHealthyRpc
            { chain: String }
            |e| { format_args!("No healthy RPC found for chain: {}", e.chain) },

        PathError
            { path: PathBuf}
            |e| { format_args!("Error when parsing path: {:?}", e.path) },

        RequestError
            { url: String }
            [ TraceError<reqwest::Error> ]
            |e| { format_args!("Error when requesting: {}", e.url) },

        RpcConnectError
            { rpc: String }
            [ TraceError<tendermint_rpc::Error> ]
            |e| { format_args!("Error when connecting to RPC: {}", e.rpc) },

        RpcConsensusParamsError
            { rpc: String }
            [ TraceError<tendermint_rpc::Error> ]
            |e| { format_args!("Unable to fetch consensus params for RPC: {}", e.rpc) },

        RpcStatusError
            { rpc: String }
            [ TraceError<tendermint_rpc::Error> ]
            |e| { format_args!("Unable to fetch status for RPC: {}", e.rpc) },

        RpcUrlWithoutAuthority
            { rpc: String }
            |e| { format_args!("Provided RPC URL without authority: {}", e.rpc) },

        RpcSyncingError
            { rpc: String }
            |e| { format_args!("Rpc node out of sync: {}", e.rpc) },

        UnhealthyEndpoints
            { endpoints: Vec<String>, retries: u8 }
            |e| {
                let endpoints = e.endpoints
                    .iter()
                    .join(", ");

                format!("Did not find a healthy endpoint after {} retries. Endpoints: {endpoints}", e.retries)
            },

        UriParseError
            { uri: String }
            [ TraceError<http::uri::InvalidUri> ]
            |e| { format_args!("Error when parsing URI: {}", e.uri) },

        UrlParseError
            { url: String }
            [ TraceError<http::Error> ]
            |e| { format_args!("Error when parsing URL: {}", e.url) },

        TendermintUrlParseError
            { url: String }
            [ TraceError<tendermint_rpc::Error> ]
            |e| { format_args!("Error when parsing URL: {}", e.url) },

        WebsocketUrlParseError
            { url: String }
            [ TraceError<tendermint_rpc::Error> ]
            |e| { format_args!("Error when parsing URL: {}", e.url) },

        StatusError
            { url: String, status : u16}
            |e| { format_args!("Incorrect HTTP response status ({}) for URL: {}", e.status, e.url) },

        UnableToBuildWebsocketEndpoint
            { rpc: String }
            [ TraceError<http::Error> ]
            |e| { format_args!("Unable to build WebSocket endpoint for RPC: {}", e.rpc) },

        UnableToConnectWithGrpc
            |_| { "Unable to connect with gRPC" },

        WebsocketConnectError
            { url: String }
            [ TraceError<tendermint_rpc::Error> ]
            |e| { format_args!("Unable to connect to WebSocket: {}", e.url) },

        WebsocketConnCloseError
            { url: String }
            [ TraceError<tendermint_rpc::Error> ]
            |e| { format_args!("Unable to close WebSocket connection: {}", e.url) },

        WebsocketTimeOutError
            { url: String }
            [ TraceError<Elapsed> ]
            |e| { format_args!("Unable to connect to WebSocket: {}", e.url) },

        WebsocketDriverError
            { url: String }
            [ TraceError<tendermint_rpc::Error> ]
            |e| { format_args!("Unable to close WebSocket driver: {}", e.url) },
    }
}