/*
* Prediction Trading REST API
*
* Place and manage prediction market orders, query positions, and transfer funds via the Prediction Trading REST API.
*
* The version of the OpenAPI document: 1.0.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
#![allow(unused_imports)]
use async_trait::async_trait;
use derive_builder::Builder;
use reqwest;
use rust_decimal::prelude::*;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use std::collections::BTreeMap;
use crate::common::{
config::ConfigurationRestApi,
models::{ParamBuildError, RestApiResponse},
utils::send_request,
};
use crate::w3w_prediction::rest_api::models;
const HAS_TIME_UNIT: bool = false;
#[async_trait]
pub trait OtcApi: Send + Sync {
async fn create_otc_blocktrade(
&self,
params: CreateOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::CreateOtcBlocktradeResponse>>;
async fn fulfil_otc_blocktrade(
&self,
params: FulfilOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::FulfilOtcBlocktradeResponse>>;
async fn get_otc_blocktrade_detail(
&self,
params: GetOtcBlocktradeDetailParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcBlocktradeDetailResponse>>;
async fn get_otc_blocktrade_events(
&self,
params: GetOtcBlocktradeEventsParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcBlocktradeEventsResponse>>;
async fn get_otc_reserved_balances(
&self,
params: GetOtcReservedBalancesParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcReservedBalancesResponse>>;
async fn list_otc_blocktrades(
&self,
params: ListOtcBlocktradesParams,
) -> anyhow::Result<RestApiResponse<models::ListOtcBlocktradesResponse>>;
async fn preview_otc_blocktrade(
&self,
params: PreviewOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::PreviewOtcBlocktradeResponse>>;
async fn remove_otc_blocktrades(
&self,
params: RemoveOtcBlocktradesParams,
) -> anyhow::Result<RestApiResponse<models::RemoveOtcBlocktradesResponse>>;
}
#[derive(Debug, Clone)]
pub struct OtcApiClient {
configuration: ConfigurationRestApi,
}
impl OtcApiClient {
pub fn new(configuration: ConfigurationRestApi) -> Self {
Self { configuration }
}
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CreateOtcBlocktradeSideEnum {
#[serde(rename = "BUY")]
Buy,
#[serde(rename = "SELL")]
Sell,
}
impl CreateOtcBlocktradeSideEnum {
#[must_use]
pub fn as_str(&self) -> &'static str {
match self {
Self::Buy => "BUY",
Self::Sell => "SELL",
}
}
}
impl std::str::FromStr for CreateOtcBlocktradeSideEnum {
type Err = Box<dyn std::error::Error + Send + Sync>;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"BUY" => Ok(Self::Buy),
"SELL" => Ok(Self::Sell),
other => Err(format!("invalid CreateOtcBlocktradeSideEnum: {}", other).into()),
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ListOtcBlocktradesStatusEnum {
#[serde(rename = "OPEN")]
Open,
#[serde(rename = "FULFILLED")]
Fulfilled,
#[serde(rename = "MATCHED")]
Matched,
#[serde(rename = "CANCELLED")]
Cancelled,
#[serde(rename = "EXPIRED")]
Expired,
#[serde(rename = "FAILED")]
Failed,
}
impl ListOtcBlocktradesStatusEnum {
#[must_use]
pub fn as_str(&self) -> &'static str {
match self {
Self::Open => "OPEN",
Self::Fulfilled => "FULFILLED",
Self::Matched => "MATCHED",
Self::Cancelled => "CANCELLED",
Self::Expired => "EXPIRED",
Self::Failed => "FAILED",
}
}
}
impl std::str::FromStr for ListOtcBlocktradesStatusEnum {
type Err = Box<dyn std::error::Error + Send + Sync>;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"OPEN" => Ok(Self::Open),
"FULFILLED" => Ok(Self::Fulfilled),
"MATCHED" => Ok(Self::Matched),
"CANCELLED" => Ok(Self::Cancelled),
"EXPIRED" => Ok(Self::Expired),
"FAILED" => Ok(Self::Failed),
other => Err(format!("invalid ListOtcBlocktradesStatusEnum: {}", other).into()),
}
}
}
/// Request parameters for the [`create_otc_blocktrade`] operation.
///
/// This struct holds all of the inputs you can pass when calling
/// [`create_otc_blocktrade`](#method.create_otc_blocktrade).
#[derive(Clone, Debug, Builder, Deserialize)]
#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
pub struct CreateOtcBlocktradeParams {
/// `PredictFun` market id
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "marketId")]
pub market_id: String,
/// ERC-1155 outcome token id
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "tokenId")]
pub token_id: String,
/// Trade side. Enum: `BUY` (BID), `SELL` (ASK)
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "side")]
pub side: CreateOtcBlocktradeSideEnum,
/// Maker amount in wei. BID：USDT; ASK：shares
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "makerAmount")]
pub maker_amount: String,
/// Taker amount in wei. BID：shares; ASK：USDT
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "takerAmount")]
pub taker_amount: String,
/// Price per share (decimal ether, e.g. `0.65`)
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "pricePerShare")]
pub price_per_share: String,
/// Expiration timestamp in seconds (GTD order)
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "expiration")]
pub expiration: i64,
}
impl CreateOtcBlocktradeParams {
/// Create a builder for [`create_otc_blocktrade`].
///
/// Required parameters:
///
/// * `market_id` — `PredictFun` market id
/// * `token_id` — ERC-1155 outcome token id
/// * `side` — Trade side. Enum: `BUY` (BID), `SELL` (ASK)
/// * `maker_amount` — Maker amount in wei. BID：USDT; ASK：shares
/// * `taker_amount` — Taker amount in wei. BID：shares; ASK：USDT
/// * `price_per_share` — Price per share (decimal ether, e.g. `0.65`)
/// * `expiration` — Expiration timestamp in seconds (GTD order)
///
#[must_use]
pub fn builder(
market_id: String,
token_id: String,
side: CreateOtcBlocktradeSideEnum,
maker_amount: String,
taker_amount: String,
price_per_share: String,
expiration: i64,
) -> CreateOtcBlocktradeParamsBuilder {
CreateOtcBlocktradeParamsBuilder::default()
.market_id(market_id)
.token_id(token_id)
.side(side)
.maker_amount(maker_amount)
.taker_amount(taker_amount)
.price_per_share(price_per_share)
.expiration(expiration)
}
}
/// Request parameters for the [`fulfil_otc_blocktrade`] operation.
///
/// This struct holds all of the inputs you can pass when calling
/// [`fulfil_otc_blocktrade`](#method.fulfil_otc_blocktrade).
#[derive(Clone, Debug, Builder, Deserialize)]
#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
pub struct FulfilOtcBlocktradeParams {
/// Maker order id (returned by maker create)
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "orderId")]
pub order_id: String,
/// One-time fulfilment token the maker shared out-of-band
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "secretToken")]
pub secret_token: String,
}
impl FulfilOtcBlocktradeParams {
/// Create a builder for [`fulfil_otc_blocktrade`].
///
/// Required parameters:
///
/// * `order_id` — Maker order id (returned by maker create)
/// * `secret_token` — One-time fulfilment token the maker shared out-of-band
///
#[must_use]
pub fn builder(order_id: String, secret_token: String) -> FulfilOtcBlocktradeParamsBuilder {
FulfilOtcBlocktradeParamsBuilder::default()
.order_id(order_id)
.secret_token(secret_token)
}
}
/// Request parameters for the [`get_otc_blocktrade_detail`] operation.
///
/// This struct holds all of the inputs you can pass when calling
/// [`get_otc_blocktrade_detail`](#method.get_otc_blocktrade_detail).
#[derive(Clone, Debug, Builder, Deserialize)]
#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
pub struct GetOtcBlocktradeDetailParams {
/// Maker order id (returned by create)
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "orderId")]
pub order_id: String,
}
impl GetOtcBlocktradeDetailParams {
/// Create a builder for [`get_otc_blocktrade_detail`].
///
/// Required parameters:
///
/// * `order_id` — Maker order id (returned by create)
///
#[must_use]
pub fn builder(order_id: String) -> GetOtcBlocktradeDetailParamsBuilder {
GetOtcBlocktradeDetailParamsBuilder::default().order_id(order_id)
}
}
/// Request parameters for the [`get_otc_blocktrade_events`] operation.
///
/// This struct holds all of the inputs you can pass when calling
/// [`get_otc_blocktrade_events`](#method.get_otc_blocktrade_events).
#[derive(Clone, Debug, Builder, Deserialize, Default)]
#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
pub struct GetOtcBlocktradeEventsParams {
/// Page size
///
/// This field is **optional.
#[builder(setter(into), default)]
#[serde(rename = "first", default)]
pub first: Option<i32>,
/// Pagination cursor
///
/// This field is **optional.
#[builder(setter(into), default)]
#[serde(rename = "after", default)]
pub after: Option<String>,
/// Filter by event types (e.g. `["MATCH_SUCCESS","EXPIRE"]`)
///
/// This field is **optional.
#[builder(setter(into), default)]
#[serde(rename = "eventTypes", default)]
pub event_types: Option<Vec<String>>,
/// Filter by market id
///
/// This field is **optional.
#[builder(setter(into), default)]
#[serde(rename = "marketId", default)]
pub market_id: Option<i64>,
}
impl GetOtcBlocktradeEventsParams {
/// Create a builder for [`get_otc_blocktrade_events`].
///
#[must_use]
pub fn builder() -> GetOtcBlocktradeEventsParamsBuilder {
GetOtcBlocktradeEventsParamsBuilder::default()
}
}
/// Request parameters for the [`get_otc_reserved_balances`] operation.
///
/// This struct holds all of the inputs you can pass when calling
/// [`get_otc_reserved_balances`](#method.get_otc_reserved_balances).
#[derive(Clone, Debug, Builder, Deserialize)]
#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
pub struct GetOtcReservedBalancesParams {
/// Assets to query (max 50)
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "assets")]
pub assets: Vec<models::GetOtcReservedBalancesAssetsParameterInner>,
}
impl GetOtcReservedBalancesParams {
/// Create a builder for [`get_otc_reserved_balances`].
///
/// Required parameters:
///
/// * `assets` — Assets to query (max 50)
///
#[must_use]
pub fn builder(
assets: Vec<models::GetOtcReservedBalancesAssetsParameterInner>,
) -> GetOtcReservedBalancesParamsBuilder {
GetOtcReservedBalancesParamsBuilder::default().assets(assets)
}
}
/// Request parameters for the [`list_otc_blocktrades`] operation.
///
/// This struct holds all of the inputs you can pass when calling
/// [`list_otc_blocktrades`](#method.list_otc_blocktrades).
#[derive(Clone, Debug, Builder, Deserialize, Default)]
#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
pub struct ListOtcBlocktradesParams {
/// Page size
///
/// This field is **optional.
#[builder(setter(into), default)]
#[serde(rename = "first", default)]
pub first: Option<i32>,
/// Pagination cursor (from previous response)
///
/// This field is **optional.
#[builder(setter(into), default)]
#[serde(rename = "after", default)]
pub after: Option<String>,
/// Filter by status. Enum: `OPEN`, `FULFILLED`, `MATCHED`, `CANCELLED`, `EXPIRED`, `FAILED`
///
/// This field is **optional.
#[builder(setter(into), default)]
#[serde(rename = "status", default)]
pub status: Option<ListOtcBlocktradesStatusEnum>,
}
impl ListOtcBlocktradesParams {
/// Create a builder for [`list_otc_blocktrades`].
///
#[must_use]
pub fn builder() -> ListOtcBlocktradesParamsBuilder {
ListOtcBlocktradesParamsBuilder::default()
}
}
/// Request parameters for the [`preview_otc_blocktrade`] operation.
///
/// This struct holds all of the inputs you can pass when calling
/// [`preview_otc_blocktrade`](#method.preview_otc_blocktrade).
#[derive(Clone, Debug, Builder, Deserialize)]
#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
pub struct PreviewOtcBlocktradeParams {
/// One-time fulfilment token the maker shared out-of-band
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "secretToken")]
pub secret_token: String,
}
impl PreviewOtcBlocktradeParams {
/// Create a builder for [`preview_otc_blocktrade`].
///
/// Required parameters:
///
/// * `secret_token` — One-time fulfilment token the maker shared out-of-band
///
#[must_use]
pub fn builder(secret_token: String) -> PreviewOtcBlocktradeParamsBuilder {
PreviewOtcBlocktradeParamsBuilder::default().secret_token(secret_token)
}
}
/// Request parameters for the [`remove_otc_blocktrades`] operation.
///
/// This struct holds all of the inputs you can pass when calling
/// [`remove_otc_blocktrades`](#method.remove_otc_blocktrades).
#[derive(Clone, Debug, Builder, Deserialize)]
#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
pub struct RemoveOtcBlocktradesParams {
/// Order ids to remove (max 100). Must be the `orderId` returned by Create OTC Blocktrade
///
/// This field is **required.
#[builder(setter(into))]
#[serde(rename = "orderIds")]
pub order_ids: Vec<String>,
}
impl RemoveOtcBlocktradesParams {
/// Create a builder for [`remove_otc_blocktrades`].
///
/// Required parameters:
///
/// * `order_ids` — Order ids to remove (max 100). Must be the `orderId` returned by Create OTC Blocktrade
///
#[must_use]
pub fn builder(order_ids: Vec<String>) -> RemoveOtcBlocktradesParamsBuilder {
RemoveOtcBlocktradesParamsBuilder::default().order_ids(order_ids)
}
}
#[async_trait]
impl OtcApi for OtcApiClient {
async fn create_otc_blocktrade(
&self,
params: CreateOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::CreateOtcBlocktradeResponse>> {
let CreateOtcBlocktradeParams {
market_id,
token_id,
side,
maker_amount,
taker_amount,
price_per_share,
expiration,
} = params;
let mut query_params = BTreeMap::new();
let body_params = BTreeMap::new();
query_params.insert("marketId".to_string(), json!(market_id));
query_params.insert("tokenId".to_string(), json!(token_id));
query_params.insert("side".to_string(), json!(side));
query_params.insert("makerAmount".to_string(), json!(maker_amount));
query_params.insert("takerAmount".to_string(), json!(taker_amount));
query_params.insert("pricePerShare".to_string(), json!(price_per_share));
query_params.insert("expiration".to_string(), json!(expiration));
send_request::<models::CreateOtcBlocktradeResponse>(
&self.configuration,
"/sapi/v1/w3w/wallet/prediction/otc/blocktrade/create",
reqwest::Method::POST,
query_params,
body_params,
if HAS_TIME_UNIT {
self.configuration.time_unit
} else {
None
},
true,
)
.await
}
async fn fulfil_otc_blocktrade(
&self,
params: FulfilOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::FulfilOtcBlocktradeResponse>> {
let FulfilOtcBlocktradeParams {
order_id,
secret_token,
} = params;
let mut query_params = BTreeMap::new();
let body_params = BTreeMap::new();
query_params.insert("orderId".to_string(), json!(order_id));
query_params.insert("secretToken".to_string(), json!(secret_token));
send_request::<models::FulfilOtcBlocktradeResponse>(
&self.configuration,
"/sapi/v1/w3w/wallet/prediction/otc/blocktrade/fulfil",
reqwest::Method::POST,
query_params,
body_params,
if HAS_TIME_UNIT {
self.configuration.time_unit
} else {
None
},
true,
)
.await
}
async fn get_otc_blocktrade_detail(
&self,
params: GetOtcBlocktradeDetailParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcBlocktradeDetailResponse>> {
let GetOtcBlocktradeDetailParams { order_id } = params;
let mut query_params = BTreeMap::new();
let body_params = BTreeMap::new();
query_params.insert("orderId".to_string(), json!(order_id));
send_request::<models::GetOtcBlocktradeDetailResponse>(
&self.configuration,
"/sapi/v1/w3w/wallet/prediction/otc/blocktrade/detail",
reqwest::Method::POST,
query_params,
body_params,
if HAS_TIME_UNIT {
self.configuration.time_unit
} else {
None
},
true,
)
.await
}
async fn get_otc_blocktrade_events(
&self,
params: GetOtcBlocktradeEventsParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcBlocktradeEventsResponse>> {
let GetOtcBlocktradeEventsParams {
first,
after,
event_types,
market_id,
} = params;
let mut query_params = BTreeMap::new();
let body_params = BTreeMap::new();
if let Some(rw) = first {
query_params.insert("first".to_string(), json!(rw));
}
if let Some(rw) = after {
query_params.insert("after".to_string(), json!(rw));
}
if let Some(rw) = event_types {
query_params.insert("eventTypes".to_string(), json!(rw));
}
if let Some(rw) = market_id {
query_params.insert("marketId".to_string(), json!(rw));
}
send_request::<models::GetOtcBlocktradeEventsResponse>(
&self.configuration,
"/sapi/v1/w3w/wallet/prediction/otc/blocktrade/events",
reqwest::Method::POST,
query_params,
body_params,
if HAS_TIME_UNIT {
self.configuration.time_unit
} else {
None
},
true,
)
.await
}
async fn get_otc_reserved_balances(
&self,
params: GetOtcReservedBalancesParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcReservedBalancesResponse>> {
let GetOtcReservedBalancesParams { assets } = params;
let mut query_params = BTreeMap::new();
let body_params = BTreeMap::new();
query_params.insert("assets".to_string(), json!(assets));
send_request::<models::GetOtcReservedBalancesResponse>(
&self.configuration,
"/sapi/v1/w3w/wallet/prediction/otc/blocktrade/reserved-balances",
reqwest::Method::POST,
query_params,
body_params,
if HAS_TIME_UNIT {
self.configuration.time_unit
} else {
None
},
true,
)
.await
}
async fn list_otc_blocktrades(
&self,
params: ListOtcBlocktradesParams,
) -> anyhow::Result<RestApiResponse<models::ListOtcBlocktradesResponse>> {
let ListOtcBlocktradesParams {
first,
after,
status,
} = params;
let mut query_params = BTreeMap::new();
let body_params = BTreeMap::new();
if let Some(rw) = first {
query_params.insert("first".to_string(), json!(rw));
}
if let Some(rw) = after {
query_params.insert("after".to_string(), json!(rw));
}
if let Some(rw) = status {
query_params.insert("status".to_string(), json!(rw));
}
send_request::<models::ListOtcBlocktradesResponse>(
&self.configuration,
"/sapi/v1/w3w/wallet/prediction/otc/blocktrade/list",
reqwest::Method::POST,
query_params,
body_params,
if HAS_TIME_UNIT {
self.configuration.time_unit
} else {
None
},
true,
)
.await
}
async fn preview_otc_blocktrade(
&self,
params: PreviewOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::PreviewOtcBlocktradeResponse>> {
let PreviewOtcBlocktradeParams { secret_token } = params;
let mut query_params = BTreeMap::new();
let body_params = BTreeMap::new();
query_params.insert("secretToken".to_string(), json!(secret_token));
send_request::<models::PreviewOtcBlocktradeResponse>(
&self.configuration,
"/sapi/v1/w3w/wallet/prediction/otc/blocktrade/preview",
reqwest::Method::POST,
query_params,
body_params,
if HAS_TIME_UNIT {
self.configuration.time_unit
} else {
None
},
true,
)
.await
}
async fn remove_otc_blocktrades(
&self,
params: RemoveOtcBlocktradesParams,
) -> anyhow::Result<RestApiResponse<models::RemoveOtcBlocktradesResponse>> {
let RemoveOtcBlocktradesParams { order_ids } = params;
let mut query_params = BTreeMap::new();
let body_params = BTreeMap::new();
query_params.insert("orderIds".to_string(), json!(order_ids));
send_request::<models::RemoveOtcBlocktradesResponse>(
&self.configuration,
"/sapi/v1/w3w/wallet/prediction/otc/blocktrade/remove",
reqwest::Method::POST,
query_params,
body_params,
if HAS_TIME_UNIT {
self.configuration.time_unit
} else {
None
},
true,
)
.await
}
}
#[cfg(all(test, feature = "w3w_prediction"))]
mod tests {
use super::*;
use crate::TOKIO_SHARED_RT;
use crate::{errors::ConnectorError, models::DataFuture, models::RestApiRateLimit};
use async_trait::async_trait;
use std::collections::HashMap;
struct DummyRestApiResponse<T> {
inner: Box<dyn FnOnce() -> DataFuture<Result<T, ConnectorError>> + Send + Sync>,
status: u16,
headers: HashMap<String, String>,
rate_limits: Option<Vec<RestApiRateLimit>>,
}
impl<T> From<DummyRestApiResponse<T>> for RestApiResponse<T> {
fn from(dummy: DummyRestApiResponse<T>) -> Self {
Self {
data_fn: dummy.inner,
status: dummy.status,
headers: dummy.headers,
rate_limits: dummy.rate_limits,
}
}
}
struct MockOtcApiClient {
force_error: bool,
}
#[async_trait]
impl OtcApi for MockOtcApiClient {
async fn create_otc_blocktrade(
&self,
_params: CreateOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::CreateOtcBlocktradeResponse>> {
if self.force_error {
return Err(ConnectorError::ConnectorClientError {
msg: "ResponseError".to_string(),
code: None,
}
.into());
}
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234567","secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}"#).unwrap_or_else(|_| serde_json::json!({}));
let dummy_response: models::CreateOtcBlocktradeResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::CreateOtcBlocktradeResponse");
let dummy = DummyRestApiResponse {
inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
status: 200,
headers: HashMap::new(),
rate_limits: None,
};
Ok(dummy.into())
}
async fn fulfil_otc_blocktrade(
&self,
_params: FulfilOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::FulfilOtcBlocktradeResponse>> {
if self.force_error {
return Err(ConnectorError::ConnectorClientError {
msg: "ResponseError".to_string(),
code: None,
}
.into());
}
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234568"}"#)
.unwrap_or_else(|_| serde_json::json!({}));
let dummy_response: models::FulfilOtcBlocktradeResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::FulfilOtcBlocktradeResponse");
let dummy = DummyRestApiResponse {
inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
status: 200,
headers: HashMap::new(),
rate_limits: None,
};
Ok(dummy.into())
}
async fn get_otc_blocktrade_detail(
&self,
_params: GetOtcBlocktradeDetailParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcBlocktradeDetailResponse>> {
if self.force_error {
return Err(ConnectorError::ConnectorClientError {
msg: "ResponseError".to_string(),
code: None,
}
.into());
}
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234567","status":"OPEN","orderData":{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","taker":"taker","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"orderType":"GTD","timeInForce":"GTD","expiration":1790000000,"filledAmount":"0","quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","isNegRisk":false,"isYieldBearing":false,"secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}}"#).unwrap_or_else(|_| serde_json::json!({}));
let dummy_response: models::GetOtcBlocktradeDetailResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::GetOtcBlocktradeDetailResponse");
let dummy = DummyRestApiResponse {
inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
status: 200,
headers: HashMap::new(),
rate_limits: None,
};
Ok(dummy.into())
}
async fn get_otc_blocktrade_events(
&self,
_params: GetOtcBlocktradeEventsParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcBlocktradeEventsResponse>> {
if self.force_error {
return Err(ConnectorError::ConnectorClientError {
msg: "ResponseError".to_string(),
code: None,
}
.into());
}
let resp_json: Value = serde_json::from_str(r#"{"cursor":"next-cursor-string","events":[{"event":"CREATE","blocktradeId":"pf-bt-001","orderId":"26080500000001234567","marketId":123,"amount":"600000000000000000000","fee":"1000000000000000","effectiveFee":"1000000000000000","price":"650000000000000000","transactionHash":"transactionHash","reason":"reason","isMaker":true,"timestamp":"2026-08-05T10:30:00.000Z"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let dummy_response: models::GetOtcBlocktradeEventsResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::GetOtcBlocktradeEventsResponse");
let dummy = DummyRestApiResponse {
inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
status: 200,
headers: HashMap::new(),
rate_limits: None,
};
Ok(dummy.into())
}
async fn get_otc_reserved_balances(
&self,
_params: GetOtcReservedBalancesParams,
) -> anyhow::Result<RestApiResponse<models::GetOtcReservedBalancesResponse>> {
if self.force_error {
return Err(ConnectorError::ConnectorClientError {
msg: "ResponseError".to_string(),
code: None,
}
.into());
}
let resp_json: Value = serde_json::from_str(r#"{"balances":[{"type":"USDT","tokenId":"tokenId","amount":"500000000000000000000"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let dummy_response: models::GetOtcReservedBalancesResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::GetOtcReservedBalancesResponse");
let dummy = DummyRestApiResponse {
inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
status: 200,
headers: HashMap::new(),
rate_limits: None,
};
Ok(dummy.into())
}
async fn list_otc_blocktrades(
&self,
_params: ListOtcBlocktradesParams,
) -> anyhow::Result<RestApiResponse<models::ListOtcBlocktradesResponse>> {
if self.force_error {
return Err(ConnectorError::ConnectorClientError {
msg: "ResponseError".to_string(),
code: None,
}
.into());
}
let resp_json: Value = serde_json::from_str(r#"{"cursor":"next-cursor-string","blocktrades":[{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let dummy_response: models::ListOtcBlocktradesResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::ListOtcBlocktradesResponse");
let dummy = DummyRestApiResponse {
inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
status: 200,
headers: HashMap::new(),
rate_limits: None,
};
Ok(dummy.into())
}
async fn preview_otc_blocktrade(
&self,
_params: PreviewOtcBlocktradeParams,
) -> anyhow::Result<RestApiResponse<models::PreviewOtcBlocktradeResponse>> {
if self.force_error {
return Err(ConnectorError::ConnectorClientError {
msg: "ResponseError".to_string(),
code: None,
}
.into());
}
let resp_json: Value = serde_json::from_str(r#"{"orderId":"orderId","status":"OPEN","orderData":{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","taker":"taker","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"orderType":"GTD","timeInForce":"GTD","expiration":1790000000,"filledAmount":"0","quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","isNegRisk":false,"isYieldBearing":false}}"#).unwrap_or_else(|_| serde_json::json!({}));
let dummy_response: models::PreviewOtcBlocktradeResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::PreviewOtcBlocktradeResponse");
let dummy = DummyRestApiResponse {
inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
status: 200,
headers: HashMap::new(),
rate_limits: None,
};
Ok(dummy.into())
}
async fn remove_otc_blocktrades(
&self,
_params: RemoveOtcBlocktradesParams,
) -> anyhow::Result<RestApiResponse<models::RemoveOtcBlocktradesResponse>> {
if self.force_error {
return Err(ConnectorError::ConnectorClientError {
msg: "ResponseError".to_string(),
code: None,
}
.into());
}
let resp_json: Value = serde_json::from_str(
r#"{"removed":["26080500000001234567"],"noop":["26080500000001234568"]}"#,
)
.unwrap_or_else(|_| serde_json::json!({}));
let dummy_response: models::RemoveOtcBlocktradesResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::RemoveOtcBlocktradesResponse");
let dummy = DummyRestApiResponse {
inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
status: 200,
headers: HashMap::new(),
rate_limits: None,
};
Ok(dummy.into())
}
}
#[test]
fn create_otc_blocktrade_required_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = CreateOtcBlocktradeParams::builder("123".to_string(),"71321045679252212594626385532706912750332728571942532289631379312455583992563".to_string(),CreateOtcBlocktradeSideEnum::Buy,"600000000000000000000".to_string(),"1000000000000000000000".to_string(),"0.65".to_string(),1790000000).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234567","secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::CreateOtcBlocktradeResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::CreateOtcBlocktradeResponse");
let resp = client.create_otc_blocktrade(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn create_otc_blocktrade_optional_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = CreateOtcBlocktradeParams::builder("123".to_string(),"71321045679252212594626385532706912750332728571942532289631379312455583992563".to_string(),CreateOtcBlocktradeSideEnum::Buy,"600000000000000000000".to_string(),"1000000000000000000000".to_string(),"0.65".to_string(),1790000000).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234567","secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::CreateOtcBlocktradeResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::CreateOtcBlocktradeResponse");
let resp = client.create_otc_blocktrade(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn create_otc_blocktrade_response_error() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: true };
let params = CreateOtcBlocktradeParams::builder(
"123".to_string(),
"71321045679252212594626385532706912750332728571942532289631379312455583992563"
.to_string(),
CreateOtcBlocktradeSideEnum::Buy,
"600000000000000000000".to_string(),
"1000000000000000000000".to_string(),
"0.65".to_string(),
1790000000,
)
.build()
.unwrap();
match client.create_otc_blocktrade(params).await {
Ok(_) => panic!("Expected an error"),
Err(err) => {
assert_eq!(err.to_string(), "Connector client error: ResponseError");
}
}
});
}
#[test]
fn fulfil_otc_blocktrade_required_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = FulfilOtcBlocktradeParams::builder(
"26080500000001234567".to_string(),
"a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string(),
)
.build()
.unwrap();
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234568"}"#)
.unwrap_or_else(|_| serde_json::json!({}));
let expected_response: models::FulfilOtcBlocktradeResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::FulfilOtcBlocktradeResponse");
let resp = client
.fulfil_otc_blocktrade(params)
.await
.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn fulfil_otc_blocktrade_optional_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = FulfilOtcBlocktradeParams::builder(
"26080500000001234567".to_string(),
"a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string(),
)
.build()
.unwrap();
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234568"}"#)
.unwrap_or_else(|_| serde_json::json!({}));
let expected_response: models::FulfilOtcBlocktradeResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::FulfilOtcBlocktradeResponse");
let resp = client
.fulfil_otc_blocktrade(params)
.await
.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn fulfil_otc_blocktrade_response_error() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: true };
let params = FulfilOtcBlocktradeParams::builder(
"26080500000001234567".to_string(),
"a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string(),
)
.build()
.unwrap();
match client.fulfil_otc_blocktrade(params).await {
Ok(_) => panic!("Expected an error"),
Err(err) => {
assert_eq!(err.to_string(), "Connector client error: ResponseError");
}
}
});
}
#[test]
fn get_otc_blocktrade_detail_required_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = GetOtcBlocktradeDetailParams::builder("26080500000001234567".to_string()).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234567","status":"OPEN","orderData":{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","taker":"taker","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"orderType":"GTD","timeInForce":"GTD","expiration":1790000000,"filledAmount":"0","quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","isNegRisk":false,"isYieldBearing":false,"secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::GetOtcBlocktradeDetailResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::GetOtcBlocktradeDetailResponse");
let resp = client.get_otc_blocktrade_detail(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn get_otc_blocktrade_detail_optional_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = GetOtcBlocktradeDetailParams::builder("26080500000001234567".to_string()).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"orderId":"26080500000001234567","status":"OPEN","orderData":{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","taker":"taker","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"orderType":"GTD","timeInForce":"GTD","expiration":1790000000,"filledAmount":"0","quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","isNegRisk":false,"isYieldBearing":false,"secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::GetOtcBlocktradeDetailResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::GetOtcBlocktradeDetailResponse");
let resp = client.get_otc_blocktrade_detail(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn get_otc_blocktrade_detail_response_error() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: true };
let params = GetOtcBlocktradeDetailParams::builder("26080500000001234567".to_string())
.build()
.unwrap();
match client.get_otc_blocktrade_detail(params).await {
Ok(_) => panic!("Expected an error"),
Err(err) => {
assert_eq!(err.to_string(), "Connector client error: ResponseError");
}
}
});
}
#[test]
fn get_otc_blocktrade_events_required_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = GetOtcBlocktradeEventsParams::builder().build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"cursor":"next-cursor-string","events":[{"event":"CREATE","blocktradeId":"pf-bt-001","orderId":"26080500000001234567","marketId":123,"amount":"600000000000000000000","fee":"1000000000000000","effectiveFee":"1000000000000000","price":"650000000000000000","transactionHash":"transactionHash","reason":"reason","isMaker":true,"timestamp":"2026-08-05T10:30:00.000Z"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::GetOtcBlocktradeEventsResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::GetOtcBlocktradeEventsResponse");
let resp = client.get_otc_blocktrade_events(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn get_otc_blocktrade_events_optional_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = GetOtcBlocktradeEventsParams::builder().first(20).after("next-cursor-string".to_string()).event_types(["null".to_string(),].to_vec()).market_id(123).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"cursor":"next-cursor-string","events":[{"event":"CREATE","blocktradeId":"pf-bt-001","orderId":"26080500000001234567","marketId":123,"amount":"600000000000000000000","fee":"1000000000000000","effectiveFee":"1000000000000000","price":"650000000000000000","transactionHash":"transactionHash","reason":"reason","isMaker":true,"timestamp":"2026-08-05T10:30:00.000Z"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::GetOtcBlocktradeEventsResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::GetOtcBlocktradeEventsResponse");
let resp = client.get_otc_blocktrade_events(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn get_otc_blocktrade_events_response_error() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: true };
let params = GetOtcBlocktradeEventsParams::builder().build().unwrap();
match client.get_otc_blocktrade_events(params).await {
Ok(_) => panic!("Expected an error"),
Err(err) => {
assert_eq!(err.to_string(), "Connector client error: ResponseError");
}
}
});
}
#[test]
fn get_otc_reserved_balances_required_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = GetOtcReservedBalancesParams::builder(vec![]).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"balances":[{"type":"USDT","tokenId":"tokenId","amount":"500000000000000000000"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::GetOtcReservedBalancesResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::GetOtcReservedBalancesResponse");
let resp = client.get_otc_reserved_balances(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn get_otc_reserved_balances_optional_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = GetOtcReservedBalancesParams::builder(vec![]).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"balances":[{"type":"USDT","tokenId":"tokenId","amount":"500000000000000000000"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::GetOtcReservedBalancesResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::GetOtcReservedBalancesResponse");
let resp = client.get_otc_reserved_balances(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn get_otc_reserved_balances_response_error() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: true };
let params = GetOtcReservedBalancesParams::builder(vec![])
.build()
.unwrap();
match client.get_otc_reserved_balances(params).await {
Ok(_) => panic!("Expected an error"),
Err(err) => {
assert_eq!(err.to_string(), "Connector client error: ResponseError");
}
}
});
}
#[test]
fn list_otc_blocktrades_required_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = ListOtcBlocktradesParams::builder().build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"cursor":"next-cursor-string","blocktrades":[{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::ListOtcBlocktradesResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::ListOtcBlocktradesResponse");
let resp = client.list_otc_blocktrades(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn list_otc_blocktrades_optional_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = ListOtcBlocktradesParams::builder().first(20).after("next-cursor-string".to_string()).status(ListOtcBlocktradesStatusEnum::Open).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"cursor":"next-cursor-string","blocktrades":[{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","secretToken":"a1b2c3d4-e5f6-7890-abcd-ef1234567890"}]}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::ListOtcBlocktradesResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::ListOtcBlocktradesResponse");
let resp = client.list_otc_blocktrades(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn list_otc_blocktrades_response_error() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: true };
let params = ListOtcBlocktradesParams::builder().build().unwrap();
match client.list_otc_blocktrades(params).await {
Ok(_) => panic!("Expected an error"),
Err(err) => {
assert_eq!(err.to_string(), "Connector client error: ResponseError");
}
}
});
}
#[test]
fn preview_otc_blocktrade_required_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = PreviewOtcBlocktradeParams::builder("a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string()).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"orderId":"orderId","status":"OPEN","orderData":{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","taker":"taker","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"orderType":"GTD","timeInForce":"GTD","expiration":1790000000,"filledAmount":"0","quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","isNegRisk":false,"isYieldBearing":false}}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::PreviewOtcBlocktradeResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::PreviewOtcBlocktradeResponse");
let resp = client.preview_otc_blocktrade(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn preview_otc_blocktrade_optional_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = PreviewOtcBlocktradeParams::builder("a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string()).build().unwrap();
let resp_json: Value = serde_json::from_str(r#"{"orderId":"orderId","status":"OPEN","orderData":{"status":"OPEN","marketId":"123","tokenId":"71321045679252212594626385532706912750332728571942532289631379312455583992563","side":0,"maker":"0x12e32db8817e292508c34111cbc4b23340df542c","taker":"taker","makerAmount":"600000000000000000000","takerAmount":"1000000000000000000000","price":0.65,"orderType":"GTD","timeInForce":"GTD","expiration":1790000000,"filledAmount":"0","quoteType":"Bid","createdAt":"2026-08-05T10:30:00.000Z","isNegRisk":false,"isYieldBearing":false}}"#).unwrap_or_else(|_| serde_json::json!({}));
let expected_response : models::PreviewOtcBlocktradeResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::PreviewOtcBlocktradeResponse");
let resp = client.preview_otc_blocktrade(params).await.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn preview_otc_blocktrade_response_error() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: true };
let params = PreviewOtcBlocktradeParams::builder(
"a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string(),
)
.build()
.unwrap();
match client.preview_otc_blocktrade(params).await {
Ok(_) => panic!("Expected an error"),
Err(err) => {
assert_eq!(err.to_string(), "Connector client error: ResponseError");
}
}
});
}
#[test]
fn remove_otc_blocktrades_required_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = RemoveOtcBlocktradesParams::builder(["null".to_string()].to_vec())
.build()
.unwrap();
let resp_json: Value = serde_json::from_str(
r#"{"removed":["26080500000001234567"],"noop":["26080500000001234568"]}"#,
)
.unwrap_or_else(|_| serde_json::json!({}));
let expected_response: models::RemoveOtcBlocktradesResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::RemoveOtcBlocktradesResponse");
let resp = client
.remove_otc_blocktrades(params)
.await
.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn remove_otc_blocktrades_optional_params_success() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: false };
let params = RemoveOtcBlocktradesParams::builder(["null".to_string()].to_vec())
.build()
.unwrap();
let resp_json: Value = serde_json::from_str(
r#"{"removed":["26080500000001234567"],"noop":["26080500000001234568"]}"#,
)
.unwrap_or_else(|_| serde_json::json!({}));
let expected_response: models::RemoveOtcBlocktradesResponse =
serde_json::from_value(resp_json.clone())
.expect("should parse into models::RemoveOtcBlocktradesResponse");
let resp = client
.remove_otc_blocktrades(params)
.await
.expect("Expected a response");
let data_future = resp.data();
let actual_response = data_future.await.unwrap();
assert_eq!(actual_response, expected_response);
});
}
#[test]
fn remove_otc_blocktrades_response_error() {
TOKIO_SHARED_RT.block_on(async {
let client = MockOtcApiClient { force_error: true };
let params = RemoveOtcBlocktradesParams::builder(["null".to_string()].to_vec())
.build()
.unwrap();
match client.remove_otc_blocktrades(params).await {
Ok(_) => panic!("Expected an error"),
Err(err) => {
assert_eq!(err.to_string(), "Connector client error: ResponseError");
}
}
});
}
}