v_exchanges 0.17.3

Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using [crypto-botters](<https://github.com/negi-grass/crypto-botters>) framework
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

use std::backtrace::Backtrace;

use adapters::generics::{
	http::{ApiError, AuthError, HandleError, IpError, RequestError},
	ws::WsError,
};
use v_utils::{
	prelude::*,
	trades::Timeframe,
	utils::{Sysexit, SysexitCode},
};

use crate::{ExchangeName, Instrument};

// Exchange Error {{{
pub type ExchangeResult<T> = Result<T, Error>;

impl From<RequestError> for Error {
	fn from(e: RequestError) -> Self {
		match e {
			RequestError::HandleResponse(HandleError::Api(ApiError::Auth(auth))) => Self::Auth(auth),
			RequestError::HandleResponse(HandleError::Api(ApiError::Ip(ip))) => Self::Ip(ip),
			other => Self::Request(other),
		}
	}
}

/// Re-export as ExchangeError for internal use to avoid rewrites
pub use Error as ExchangeError;

#[derive(Debug, miette::Diagnostic, derive_more::Display, thiserror::Error, derive_more::From)]
pub enum Error {
	/// exchange-specific or method-specific stuff
	#[diagnostic(transparent)]
	#[from(skip)]
	Request(RequestError),
	/// Specific to websocket
	#[diagnostic(transparent)]
	Ws(WsError),

	// commonly understood cases {{{1
	#[diagnostic(transparent)]
	Timeframe(UnsupportedTimeframeError),
	#[diagnostic(transparent)]
	Range(RequestRangeError),
	#[diagnostic(transparent)]
	Auth(AuthError),
	#[diagnostic(transparent)]
	Ip(IpError),
	//,}}}1
	/// our internal markings
	#[diagnostic(transparent)]
	Method(MethodError),
	#[error(transparent)]
	Other(Report),
}

impl SysexitCode for Error {
	fn sysexit(&self) -> Sysexit {
		match self {
			Self::Auth(_) | Self::Ip(_) => Sysexit::NoPerm,
			_ => Sysexit::None,
		}
	}
}

#[derive(Debug, miette::Diagnostic, thiserror::Error, derive_new::new)]
#[error("Chosen exchange does not support the requested timeframe. Provided: {provided}, allowed: {allowed:?}")]
#[diagnostic(code(v_exchanges::unsupported_timeframe), help("Use one of the allowed timeframes for this exchange."))]
pub struct UnsupportedTimeframeError {
	provided: Timeframe,
	allowed: Vec<Timeframe>,
	#[new(value = "Backtrace::capture()")]
	backtrace: Backtrace,
}

#[derive(Debug, miette::Diagnostic, thiserror::Error, derive_new::new)]
pub enum MethodError {
	/// Means that it's **not expected** to be implemented, not only that it's not implemented now. For things that are yet to be implemented I just put `unimplemented!()`.
	#[error("Method not implemented for the requested exchange and instrument: ({exchange}, {instrument})")]
	#[diagnostic(
		code(v_exchanges::method::not_implemented),
		help("This method is not expected to be implemented for this exchange/instrument combination.")
	)]
	MethodNotImplemented {
		exchange: ExchangeName,
		instrument: Instrument,
		#[new(value = "Backtrace::capture()")]
		backtrace: Backtrace,
	},
	#[error("Requested exchange does not support the method for chosen instrument: ({exchange}, {instrument})")]
	#[diagnostic(code(v_exchanges::method::not_supported), help("This exchange does not support this method for the specified instrument type."))]
	MethodNotSupported {
		exchange: ExchangeName,
		instrument: Instrument,
		#[new(value = "Backtrace::capture()")]
		backtrace: Backtrace,
	},
}

#[derive(Debug, miette::Diagnostic, derive_more::Display, thiserror::Error, derive_more::From)]
pub enum RequestRangeError {
	#[diagnostic(transparent)]
	OutOfRange(OutOfRangeError),
	#[error(transparent)]
	Others(Report),
}

#[derive(derive_more::Debug, miette::Diagnostic, thiserror::Error, derive_new::new)]
#[error("Effective provided limit is out of range (could be translated from Start:End / tf). Allowed: {allowed:?}, provided: {provided}")]
#[diagnostic(code(v_exchanges::range::out_of_range), help("Adjust the request parameters to fall within the allowed range."))]
pub struct OutOfRangeError {
	allowed: std::ops::RangeInclusive<u32>,
	provided: u32,
	#[new(value = "Backtrace::capture()")]
	backtrace: Backtrace,
}
//,}}}