pub struct BaseCore {
pub exchange: Exchange,
}Expand description
A minimal Core wrapping a bare Exchange with NO overrides. Lets code that
only has an Exchange value — Value snapshots (value.rs), the constructor
(after_construct), and base unit tests — call ExchangeBase/ExchangeRuntime
trait methods, which all resolve to the base defaults (review #1: base
methods are trait methods now, so a bare Exchange can’t call them directly).
Fields§
§exchange: ExchangeImplementations§
Methods from Deref<Target = Exchange>§
Sourcepub fn initialize_properties(&mut self, described: Value)
pub fn initialize_properties(&mut self, described: Value)
Apply a merged describe() + constructor-config map onto the typed
fields. The Rust counterpart of Go’s initializeProperties
(go/v4/exchange_options.go) and of the TS constructor’s
deepExtend(this, describe(), userConfig) — which Rust cannot do
directly because Exchange is a struct, not a dynamic object.
Each Core’s generated init() used to inline ~84 lines of this, which
is why every field carried its own precedence guard: config was applied
in new() BEFORE describe() ran, so describe() had to be stopped
from clobbering it. Here the config is merged over describe() first
(Go’s deepExtend(describe, userConfig)), so last-write-wins is the
precedence rule and no guards are needed.
Absent keys leave the base default in place — the equivalent of Go’s
SafeString(props, key, default).
pub fn urlencode_kv(&self, params: &Value) -> String
pub fn implode_params(&self, path: Value, params: Value) -> Value
pub fn json_str(&self, v: &Value) -> String
pub fn hmac( &self, data: Value, secret: Value, hash: Value, optional_args: &[Value], ) -> Value
pub fn hmac_typed( &self, data: &[u8], secret: &[u8], hash: &str, digest: &str, ) -> Result<String>
pub fn hash(&self, data: Value, algo: Value, optional_args: &[Value]) -> Value
pub fn hash_typed(&self, data: &[u8], algo: &str, digest: &str) -> String
pub fn binary_to_base64(&self, data: Value, _optional_args: &[Value]) -> Value
pub fn base64_to_binary(&self, s: Value, _optional_args: &[Value]) -> Value
pub fn binary_to_base16(&self, data: Value, _optional_args: &[Value]) -> Value
pub fn base16_to_binary(&self, s: Value, _optional_args: &[Value]) -> Value
pub fn milliseconds(&self) -> Value
pub fn seconds(&self) -> Value
pub fn microseconds(&self) -> Value
pub fn iso8601(&self, ts: Value) -> Value
pub fn parse8601(&self, s: Value) -> Value
Sourcepub fn dispatch_guard_enter(&mut self, method: &str) -> bool
pub fn dispatch_guard_enter(&mut self, method: &str) -> bool
Enter the guard for method. Returns false if method is already on
the dispatch stack (re-entry — caller should fall through to the base
body); otherwise pushes it and returns true.
Sourcepub fn dispatch_guard_exit(&mut self)
pub fn dispatch_guard_exit(&mut self)
Leave the guard (pop the most-recently entered method).
Sourcepub fn build_implicit_api(&mut self)
pub fn build_implicit_api(&mut self)
Builds the name → (path, scope, verb) dispatch table by walking
the self.api Value::Map. Called lazily on first dynamic call.
The api block layout is:
{ get/post/put/delete/patch (any case). All path components
before the verb concatenate into the scope (joined by _).
Sourcepub fn exception_message(&self, exc: Value, _optional_args: &[Value]) -> Value
pub fn exception_message(&self, exc: Value, _optional_args: &[Value]) -> Value
Coerce a caught panic payload into the [ClassName] message
shape TS uses (see Exchange.exceptionMessage). Truncates to
100k chars to match. Rust panics carry just a string in Value,
so we trust it as the formatted message and trim it. Used by
exchanges that re-throw with a contextual prefix in their
catch arms (grvt.transfer is the canonical case).
Sourcepub fn get_ccxt_version(&self) -> Value
pub fn get_ccxt_version(&self) -> Value
Port of Exchange.getCcxtVersion(). The TS reads the static
Exchange.ccxtVersion (a class member the release process bumps); the
transpiler can’t lower that (Exchange as any).ccxtVersion static access,
so getCcxtVersion is dropped from exchange_generated.rs and lives here
as a hand-written stub instead. Value mirrors ts/src/base/Exchange.ts’s
static ccxtVersion (== package.json “version”); only foxbit consumes it
(the X-FB-CLIENT-VERSION request header), and no static fixture asserts
the header, so a version bump can’t break the suites.
pub fn safe_value_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
pub fn safe_string_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
pub fn safe_integer_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
pub fn safe_float_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
pub fn safe_number_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
pub fn safe_bool_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
pub fn safe_dict_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
pub fn safe_list_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
pub fn safe_value( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
pub fn safe_value2( &self, obj: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
pub fn safe_value_n( &self, obj: Value, keys: Value, optional_args: &[Value], ) -> Value
pub fn safe_string( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
pub fn safe_string2( &self, obj: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
pub fn safe_string_n( &self, obj: Value, keys: Value, optional_args: &[Value], ) -> Value
pub fn safe_string_upper( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
Sourcepub fn safe_string_upper_k(
&self,
obj: Value,
key: &str,
optional_args: &[Value],
) -> Value
pub fn safe_string_upper_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
safe_string_upper with a &str key — the safe_*_k twin.
pub fn safe_string_lower_n( &self, obj: Value, keys: Value, optional_args: &[Value], ) -> Value
pub fn safe_string_upper_n( &self, obj: Value, keys: Value, optional_args: &[Value], ) -> Value
pub fn safe_string_lower( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
Sourcepub fn safe_string_lower_k(
&self,
obj: Value,
key: &str,
optional_args: &[Value],
) -> Value
pub fn safe_string_lower_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
safe_string_lower with a &str key — the safe_*_k twin of the
lookup above (same get_value_k path as the rest of the family).
pub fn safe_string_lower2( &self, obj: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
pub fn safe_string_upper2( &self, obj: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
Sourcepub fn super_currency(&self, _code: Value) -> Value
pub fn super_currency(&self, _code: Value) -> Value
super.X(...) from derived exchanges — routes back to the base
Exchange impl. These stubs return Value::Null; they exist so
transpiled self.super_X() calls type-check.
pub fn super_handle_errors( &self, _code: Value, _reason: Value, _url: Value, _method: Value, _headers: Value, _body: Value, _response: Value, _request_headers: Value, _request_body: Value, ) -> Value
pub fn set_last_rest_request_timestamp(&self)
pub fn set_last_request(&self, request: Value)
pub fn get_fetch_cache(&self) -> Value
pub fn add_fetch_cache(&self, data: Value)
pub fn client(&mut self, args: &[Value]) -> Value
pub fn spawn(&self, args: &[Value]) -> Value
pub async fn delay(&mut self, ms: Value, args: &[Value]) -> Value
pub fn order_book(&self, args: &[Value]) -> Value
pub fn indexed_order_book(&self, args: &[Value]) -> Value
pub fn counted_order_book(&self, args: &[Value]) -> Value
pub fn safe_order_tracker(&self, _args: &[Value]) -> Value
pub async fn un_watch(&mut self, _topic: Value, _args: &[Value]) -> Value
pub fn send(&self, _payload: Value) -> Value
pub fn lock_id(&self, _args: &[Value]) -> Value
pub fn unlock_id(&self, _args: &[Value]) -> Value
pub fn lock_last_nonce(&self, _args: &[Value]) -> Value
pub fn unlock_last_nonce(&self, _args: &[Value]) -> Value
pub fn extend_exchange_options(&self, _args: &[Value]) -> Value
pub fn on_error(&self, _args: &[Value]) -> Value
pub fn on_close(&self, _args: &[Value]) -> Value
pub fn on_pong(&self, _args: &[Value]) -> Value
Sourcepub fn crc32(&self, args: &[Value]) -> Value
pub fn crc32(&self, args: &[Value]) -> Value
CRC-32 checksum — used by a few WS order-book reconcilers (bitget, bitfinex, independentreserve). Stub returns 0; will be replaced with the real algorithm when those order books need it.
Sourcepub fn decode_proto_msg(&self, args: &[Value]) -> Value
pub fn decode_proto_msg(&self, args: &[Value]) -> Value
decode_proto_msg(message) — exchange-specific protobuf decoder
(mexc). message is the binary frame carried as a byte array; decode
it into mexc’s PushDataV3ApiWrapper shape (matching protobufjs
.toJSON()) so the ported handlers consume it unchanged.
Sourcepub async fn load_order_book(&mut self, _args: &[Value]) -> Value
pub async fn load_order_book(&mut self, _args: &[Value]) -> Value
loadOrderBook — WS helper used by some bookkeeping methods.
Stubbed identically to the unwatch flow.
Sourcepub fn remove0x_prefix(&self, hex_data: Value) -> Value
pub fn remove0x_prefix(&self, hex_data: Value) -> Value
remove0xPrefix(hexData) — strips a leading 0x/0X if present.
Sourcepub fn handle_http_status_code(
&self,
code: Value,
reason: Value,
url: Value,
method: Value,
body: Value,
)
pub fn handle_http_status_code( &self, code: Value, reason: Value, url: Value, method: Value, body: Value, )
handleHttpStatusCode(code, reason, url, method, body) — throws the
httpExceptions class for the status; a status outside the table passes.
Sourcepub fn check_required_dependencies(&self) -> Value
pub fn check_required_dependencies(&self) -> Value
checkRequiredDependencies() — a no-op in Rust; all crypto deps are
compiled in.
Sourcepub fn rand_number(&self, size: Value) -> Value
pub fn rand_number(&self, size: Value) -> Value
randNumber(size) — a random integer with size decimal digits.
Sourcepub fn random_bytes(&self, length: Value) -> Value
pub fn random_bytes(&self, length: Value) -> Value
randomBytes(length) — length random bytes as a hex string.
Sourcepub fn convert_to_big_int(&self, value: Value) -> Value
pub fn convert_to_big_int(&self, value: Value) -> Value
convertToBigInt(value) — the Value-bag has no distinct bigint type,
so coerce to a 64-bit integer.
Sourcepub fn fix_stringified_json_members(&self, content: Value) -> Value
pub fn fix_stringified_json_members(&self, content: Value) -> Value
fixStringifiedJsonMembers(content) — un-escapes a JSON string whose
members are themselves stringified JSON (used by bingx).
Sourcepub fn binary_concat_array(&self, arr: Value) -> Value
pub fn binary_concat_array(&self, arr: Value) -> Value
binaryConcatArray(arrayOfChunks) — concatenates hex-string chunks.
Sourcepub fn uuid5(&self, namespace: Value, name: Value) -> Value
pub fn uuid5(&self, namespace: Value, name: Value) -> Value
uuid5(namespace, name) — RFC-4122 v5 (SHA-1 based) UUID.
Sourcepub fn eth_abi_encode(&self, types: Value, values: Value) -> Value
pub fn eth_abi_encode(&self, types: Value, values: Value) -> Value
ethAbiEncode(types, values) — Solidity abi.encode of a head-only
(all-static) tuple: every element becomes one 32-byte word. Supports the
static types the callers use (address, bytesN, uint*/int*, bool). Dynamic
types (bytes, string, arrays) are not needed (polymarket ERC-7739) and
return Null. Values arrive as: bytesN → binary Value::Arr (or 0x-hex
string); uint/int → Value::Int or a decimal/0x-hex string (big uint256
like tokenId exceed i64, so string form is preserved by convert_to_big_int);
address → 0x-hex string. Result is a binary Value::Arr that hash(...)
consumes via value_to_bytes.
Sourcepub fn set_property(&self, _property: Value, _optional_args: &[Value]) -> Value
pub fn set_property(&self, _property: Value, _optional_args: &[Value]) -> Value
setProperty(this, key, value) — dynamic field setter. The typed
Exchange struct has no Value-shaped dynamic field store, so this
is currently a no-op (the receiver arg is dropped by the transpiler).
Sourcepub fn axolotl(
&self,
_payload: Value,
_hex_key: Value,
_ed25519: Value,
) -> Value
pub fn axolotl( &self, _payload: Value, _hex_key: Value, _ed25519: Value, ) -> Value
axolotl(payload, hexKey, ed25519) — curve25519 signing (waves).
Sourcepub fn retrieve_stark_account(
&self,
_signature: Value,
_class_hash: Value,
_proxy_hash: Value,
) -> Value
pub fn retrieve_stark_account( &self, _signature: Value, _class_hash: Value, _proxy_hash: Value, ) -> Value
retrieveStarkAccount(signature, accountClassHash, accountProxyClassHash).
Sourcepub fn starknet_encode_structured_data(
&self,
_domain: Value,
_types: Value,
_data: Value,
_address: Value,
) -> Value
pub fn starknet_encode_structured_data( &self, _domain: Value, _types: Value, _data: Value, _address: Value, ) -> Value
starknetEncodeStructuredData(domain, messageTypes, messageData, address).
Sourcepub fn starknet_sign(&self, _msg_hash: Value, _pri: Value) -> Value
pub fn starknet_sign(&self, _msg_hash: Value, _pri: Value) -> Value
starknetSign(msgHash, pri).
Sourcepub fn extended_starknet_sign(&self, _msg_hash: Value, _pri: Value) -> Value
pub fn extended_starknet_sign(&self, _msg_hash: Value, _pri: Value) -> Value
extendedStarknetSign(msgHash, pri) — starknet-curve signing for the
extended exchange. Stub: starknet crypto (poseidon/stark-curve) is
not ported to Rust yet, matching starknet_sign above.
Sourcepub fn extended_starknet_get_selector_from_name(&self, _name: Value) -> Value
pub fn extended_starknet_get_selector_from_name(&self, _name: Value) -> Value
extendedStarknetGetSelectorFromName(name).
Sourcepub fn extended_starknet_compute_poseidon_hash_on_elements(
&self,
_data: Value,
) -> Value
pub fn extended_starknet_compute_poseidon_hash_on_elements( &self, _data: Value, ) -> Value
extendedStarknetComputePoseidonHashOnElements(data).
Sourcepub fn to_dydx_long(&self, _num_str: Value) -> Value
pub fn to_dydx_long(&self, _num_str: Value) -> Value
toDydxLong(numStr).
Sourcepub fn retrieve_dydx_credentials(&self, _entropy: Value) -> Value
pub fn retrieve_dydx_credentials(&self, _entropy: Value) -> Value
retrieveDydxCredentials(entropy).
Sourcepub async fn load_dydx_protos(&self) -> Value
pub async fn load_dydx_protos(&self) -> Value
loadDydxProtos().
Sourcepub fn encode_dydx_tx_raw(&self, _sign_doc: Value, _signature: Value) -> Value
pub fn encode_dydx_tx_raw(&self, _sign_doc: Value, _signature: Value) -> Value
encodeDydxTxRaw(signDoc, signature).
Sourcepub fn encode_dydx_tx_for_simulation(
&self,
_message: Value,
_memo: Value,
_sequence: Value,
_public_key: Value,
) -> Value
pub fn encode_dydx_tx_for_simulation( &self, _message: Value, _memo: Value, _sequence: Value, _public_key: Value, ) -> Value
encodeDydxTxForSimulation(message, memo, sequence, publicKey).
Sourcepub fn encode_dydx_tx_for_signing(
&self,
_message: Value,
_memo: Value,
_chain_id: Value,
_account: Value,
_authenticators: Value,
_optional_args: &[Value],
) -> Value
pub fn encode_dydx_tx_for_signing( &self, _message: Value, _memo: Value, _chain_id: Value, _account: Value, _authenticators: Value, _optional_args: &[Value], ) -> Value
encodeDydxTxForSigning(message, memo, chainId, account, authenticators, fee?).
Sourcepub async fn load_lighter_library(
&self,
_library_path: Value,
_chain_id: Value,
_private_key: Value,
_api_key_index: Value,
_account_index: Value,
_optional_args: &[Value],
) -> Value
pub async fn load_lighter_library( &self, _library_path: Value, _chain_id: Value, _private_key: Value, _api_key_index: Value, _account_index: Value, _optional_args: &[Value], ) -> Value
loadLighterLibrary(libraryPath, chainId, privateKey, apiKeyIndex, accountIndex, createClient?).
Sourcepub fn lighter_create_client(
&self,
_signer: Value,
_chain_id: Value,
_private_key: Value,
_api_key_index: Value,
_account_index: Value,
) -> Value
pub fn lighter_create_client( &self, _signer: Value, _chain_id: Value, _private_key: Value, _api_key_index: Value, _account_index: Value, ) -> Value
lighterCreateClient(signer, chainId, privateKey, apiKeyIndex, accountIndex).
Sourcepub fn lighter_generate_api_key(&self, _signer: Value) -> Value
pub fn lighter_generate_api_key(&self, _signer: Value) -> Value
lighterGenerateApiKey(signer).
Sourcepub async fn get_zk_transfer_signature_obj(
&self,
_seeds: Value,
_optional_args: &[Value],
) -> Value
pub async fn get_zk_transfer_signature_obj( &self, _seeds: Value, _optional_args: &[Value], ) -> Value
getZKTransferSignatureObj(seeds, order) — apex StarkEx signing.
Sourcepub async fn get_zk_contract_signature_obj(
&self,
_seeds: Value,
_optional_args: &[Value],
) -> Value
pub async fn get_zk_contract_signature_obj( &self, _seeds: Value, _optional_args: &[Value], ) -> Value
getZKContractSignatureObj(seeds, order) — apex StarkEx signing.
Sourcepub async fn futures_transfer(
&self,
_code: Value,
_amount: Value,
_transfer_type: Value,
_optional_args: &[Value],
) -> Value
pub async fn futures_transfer( &self, _code: Value, _amount: Value, _transfer_type: Value, _optional_args: &[Value], ) -> Value
futuresTransfer(code, amount, type, params?) — binance futures
wallet transfer; inherited by binancecoinm / binanceusdm.
Sourcepub fn lighter_sign_create_order(
&self,
_signer: Value,
_request: Value,
) -> Value
pub fn lighter_sign_create_order( &self, _signer: Value, _request: Value, ) -> Value
lighterSign*(signer, request) — lighter zk-proof signing helpers.
pub fn lighter_sign_create_grouped_orders( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_sign_cancel_order( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_sign_cancel_all_orders( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_sign_withdraw(&self, _signer: Value, _request: Value) -> Value
pub fn lighter_sign_create_sub_account( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_sign_modify_order( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_sign_transfer(&self, _signer: Value, _request: Value) -> Value
pub fn lighter_sign_update_leverage( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_sign_update_margin( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_sign_approve_integrator( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_sign_change_pubkey( &self, _signer: Value, _request: Value, ) -> Value
pub fn lighter_create_auth_token( &self, _signer: Value, _request: Value, ) -> Value
Sourcepub fn urlencode_with_array_repeat(&self, params: Value) -> Value
pub fn urlencode_with_array_repeat(&self, params: Value) -> Value
urlencodeWithArrayRepeat(params) — qs.stringify(object, { arrayFormat: 'repeat' }):
array values repeat the key (a=1&a=2); scalars encode normally.
pub fn safe_integer( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
pub fn safe_integer2( &self, obj: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
pub fn safe_integer_n( &self, obj: Value, keys: Value, optional_args: &[Value], ) -> Value
Sourcepub fn safe_integer_product(
&self,
obj: Value,
key: Value,
factor: Value,
optional_args: &[Value],
) -> Value
pub fn safe_integer_product( &self, obj: Value, key: Value, factor: Value, optional_args: &[Value], ) -> Value
Reads obj[key] as a number, multiplies by factor, and casts
to i64. Used to convert seconds → milliseconds for timestamps.
Sourcepub fn safe_integer_product_k(
&self,
obj: Value,
key: &str,
factor: Value,
optional_args: &[Value],
) -> Value
pub fn safe_integer_product_k( &self, obj: Value, key: &str, factor: Value, optional_args: &[Value], ) -> Value
safe_integer_product with a &str key — the safe_*_k twin.
pub fn safe_integer_product2( &self, obj: Value, k1: Value, k2: Value, factor: Value, optional_args: &[Value], ) -> Value
pub fn safe_integer_product_n( &self, obj: Value, keys: Value, factor: Value, optional_args: &[Value], ) -> Value
pub fn safe_timestamp2( &self, obj: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
pub fn safe_timestamp_n( &self, obj: Value, keys: Value, optional_args: &[Value], ) -> Value
pub fn safe_float( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
Sourcepub fn safe_timestamp(
&self,
obj: Value,
key: Value,
optional_args: &[Value],
) -> Value
pub fn safe_timestamp( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
safeTimestamp(o, k) — parseInt(asFloat(value) * 1000). The
value is read as a float (seconds, possibly fractional) and
converted to integer milliseconds.
Sourcepub fn safe_timestamp_k(
&self,
obj: Value,
key: &str,
optional_args: &[Value],
) -> Value
pub fn safe_timestamp_k( &self, obj: Value, key: &str, optional_args: &[Value], ) -> Value
safe_timestamp with a &str key — the safe_*_k twin.
Sourcepub fn is_empty(&self, v: Value) -> Value
pub fn is_empty(&self, v: Value) -> Value
isEmpty(value) — true when an array/dict is empty, or the
value is null/undefined. Scalars (strings, numbers, bools) are
never considered empty — mirrors functions/generic.ts.
pub fn value_is_defined(&self, v: Value) -> Value
pub fn extend(&self, a: Value, optional_args: &[Value]) -> Value
pub fn deep_extend(&self, a: Value, optional_args: &[Value]) -> Value
pub fn omit(&self, obj: Value, keys: Value, _optional_args: &[Value]) -> Value
pub fn omit_zero(&self, v: Value) -> Value
pub fn to_array(&self, v: Value) -> Value
pub fn array_concat(&self, a: Value, b: Value) -> Value
pub fn array_slice( &self, v: Value, start: Value, optional_args: &[Value], ) -> Value
pub fn in_array(&self, needle: Value, haystack: Value) -> Value
pub fn unique(&self, v: Value) -> Value
pub fn index_by(&self, arr: Value, key: Value) -> Value
pub fn index_by_safe(&self, arr: Value, key: Value) -> Value
pub fn group_by( &self, arr: Value, key: Value, _optional_args: &[Value], ) -> Value
pub fn filter_by( &self, arr: Value, key: Value, value: Value, _optional_args: &[Value], ) -> Value
Sourcepub fn sort_by(&self, arr: Value, key: Value, optional_args: &[Value]) -> Value
pub fn sort_by(&self, arr: Value, key: Value, optional_args: &[Value]) -> Value
sortBy(array, key, descending=false) — stable sort of an array
of objects by obj[key]. Mirrors functions/generic.ts.
Sourcepub fn sort_by2(
&self,
arr: Value,
k1: Value,
k2: Value,
optional_args: &[Value],
) -> Value
pub fn sort_by2( &self, arr: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
sortBy2(array, key1, key2, descending=false) — sort by key1,
then key2 as a tiebreaker. Mirrors functions/generic.ts.
pub fn keysort(&self, obj: Value, _optional_args: &[Value]) -> Value
Sourcepub fn aggregate(&self, arr: Value) -> Value
pub fn aggregate(&self, arr: Value) -> Value
aggregate(bidasks) — groups [price, volume] rows by price,
summing volume and dropping zero-volume rows. Preserves the
first-occurrence order of prices. Mirrors functions/misc.ts.
pub fn map_to_safe_map(&self, v: Value) -> Value
pub fn create_safe_dictionary(&self, _optional_args: &[Value]) -> Value
pub fn check_option_string( &self, _method_name: Value, _option_name: Value, value: Value, ) -> Value
pub fn check_option_bool( &self, _method_name: Value, _option_name: Value, value: Value, ) -> Value
pub fn check_option_integer( &self, _method_name: Value, _option_name: Value, value: Value, ) -> Value
Sourcepub fn clone_value(&self, v: Value) -> Value
pub fn clone_value(&self, v: Value) -> Value
clone(value) — CCXT’s deep clone, distinct from Rust’s Clone trait.
We disambiguate by name; the transpiler emits self.clone(x).
Sourcepub fn sum(&self, optional_args: &[Value]) -> Value
pub fn sum(&self, optional_args: &[Value]) -> Value
sum(...) — variadic numeric sum. Pure variadic (0 fixed
args) so single-arg sum(x) (e.g. from test.sum) also works.
Sourcepub fn parse_json_value(&self, v: Value) -> Value
pub fn parse_json_value(&self, v: Value) -> Value
parse_json(text) — JSON parse. Mirrors CCXT parseJson, which
runs onJsonResponse first: when quoteJsonNumbers is on
(default), every object number VALUE is wrapped in quotes before
parsing so big integer ids (e.g. bingx’s 18-digit orderId) and
precise decimals survive as strings instead of lossy f64/i64.
Sourcepub fn clone_self(&self) -> Exchange
pub fn clone_self(&self) -> Exchange
Test helper: tests sometimes call exchange.clone() to deep-copy
state. We don’t implement structural clone (the trait pointer
can’t be cloned safely) — return a fresh empty Exchange so the
call compiles and tests can move on.
No-arg exchange.clone() form — a structural copy of every
Value field. The copy gets a fresh Internals (no shared http
client / derived pointers), which is all the transpiled tests need.
Sourcepub fn clone(&self, v: Value) -> Value
pub fn clone(&self, v: Value) -> Value
clone(v) — deep-clone a Value. Matches TS exchange.clone(x).
Note: keep this name even though it shadows the (manual) clone_self,
because the transpiled tests call exchange.clone(value). Empty-arg
calls exchange.clone() get post-processed to clone_self().
Sourcepub fn prop(&self, key: &Value) -> Value
pub fn prop(&self, key: &Value) -> Value
Dynamic-property lookup for transpiled base tests. The TS code
does exchange['options'], exchange['markets'], etc. — this
reads from the unified to_value() view so both access paths
(exchange.prop(k) and testSharedMethods.exchangeProp) agree.
Sourcepub fn to_value(&self) -> Value
pub fn to_value(&self) -> Value
Full Value::Map snapshot of every transpiler-visible field —
the Rust analogue of indexing a JS object by property name.
Used by prop() and by the base-test exchangeProp shim.
pub fn base16ToBinary(&self, hex: Value, optional_args: &[Value]) -> Value
pub fn base58_to_binary(&self, s: Value, _optional_args: &[Value]) -> Value
pub fn binary_to_base58(&self, b: Value, _optional_args: &[Value]) -> Value
pub fn binary_length(&self, b: Value, _optional_args: &[Value]) -> Value
Sourcepub fn is_binary_message(&self, v: Value, _optional_args: &[Value]) -> Value
pub fn is_binary_message(&self, v: Value, _optional_args: &[Value]) -> Value
isBinaryMessage — in this port a binary buffer is a
Value::Array of byte-valued ints (see base16_to_binary,
string_to_binary). instanceof Uint8Array can’t transpile.
Sourcepub fn number_to_be(&self, n: Value, optional_args: &[Value]) -> Value
pub fn number_to_be(&self, n: Value, optional_args: &[Value]) -> Value
numberToBE(n, padding) — big-endian byte array of width padding.
Sourcepub fn parse_date(&self, s: Value, _optional_args: &[Value]) -> Value
pub fn parse_date(&self, s: Value, _optional_args: &[Value]) -> Value
parseDate(x) — ports functions/time.ts. Parses an ISO-8601
timestamp (with T/Z or a plain YYYY-MM-DD HH:MM:SS form,
treated as UTC) into epoch milliseconds. Invalid → Null.
pub fn is_binary_message_var(&self, v: Value, _optional_args: &[Value]) -> Value
Sourcepub fn ymd(&self, ts: Value, optional_args: &[Value]) -> Value
pub fn ymd(&self, ts: Value, optional_args: &[Value]) -> Value
ymd(timestamp, infix='') — like yyyymmdd but the infix
defaults to empty (TS functions/time.ts).
pub fn safe_float_n( &self, obj: Value, keys: Value, optional_args: &[Value], ) -> Value
pub fn safe_float2( &self, obj: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
pub fn safeString2( &self, obj: Value, k1: Value, k2: Value, optional_args: &[Value], ) -> Value
Sourcepub fn binary_concat(&self, first: Value, optional_args: &[Value]) -> Value
pub fn binary_concat(&self, first: Value, optional_args: &[Value]) -> Value
binaryConcat(a, b, ...) — concatenates byte buffers. The
variadic call-site wrap folds the tail args into optional_args.
pub fn stringToBase64(&self, s: Value, optional_args: &[Value]) -> Value
Sourcepub fn binary_to_string(&self, b: Value, _optional_args: &[Value]) -> Value
pub fn binary_to_string(&self, b: Value, _optional_args: &[Value]) -> Value
binaryToString(buffer) — decodes a byte buffer as UTF-8.
pub fn string_to_binary(&self, s: Value, _optional_args: &[Value]) -> Value
Sourcepub fn urlencode_base64(&self, v: Value, _optional_args: &[Value]) -> Value
pub fn urlencode_base64(&self, v: Value, _optional_args: &[Value]) -> Value
urlencodeBase64(payload) — url-safe base64 with +/ → -_
and trailing = padding stripped. Accepts a string or a byte
buffer (Value::Array).
Sourcepub fn urlencode_nested(&self, v: Value, _optional_args: &[Value]) -> Value
pub fn urlencode_nested(&self, v: Value, _optional_args: &[Value]) -> Value
urlencodeNested(object) — qs.stringify(object, { encodeValuesOnly: true }):
nested maps → parent[child], arrays → parent[index], only
values are percent-encoded.
pub fn is_json_encoded_object(&self, optional_args: &[Value]) -> Value
pub fn strip(&self, s: Value, _optional_args: &[Value]) -> Value
pub fn sort(&self, v: Value, _optional_args: &[Value]) -> Value
Sourcepub fn round_timeframe(&self, tf: Value, ts: Value, direction: Value) -> Value
pub fn round_timeframe(&self, tf: Value, ts: Value, direction: Value) -> Value
roundTimeframe(timeframe, timestamp, direction) — snap a
timestamp to the timeframe boundary (down by default, up for
ROUND_UP).
pub async fn sleep(&self, ms: Value) -> Value
Sourcepub fn eth_get_address_from_private_key(
&self,
pk: Value,
_optional_args: &[Value],
) -> Value
pub fn eth_get_address_from_private_key( &self, pk: Value, _optional_args: &[Value], ) -> Value
ethGetAddressFromPrivateKey(pk) — derive the Ethereum address
(keccak256 of the uncompressed secp256k1 public key, last 20 bytes).
pub fn exists_file(&self, p: Value) -> Value
pub fn read_file(&self, p: Value) -> Value
pub fn write_file(&self, p: Value, content: Value) -> Value
pub fn get_temp_dir(&self) -> Value
pub fn get_property(&self, obj: Value, key: Value) -> Value
pub fn yymmdd(&self, ts: Value, optional_args: &[Value]) -> Value
pub fn yyyymmdd(&self, ts: Value, optional_args: &[Value]) -> Value
Sourcepub fn ymdhms(&self, ts: Value, optional_args: &[Value]) -> Value
pub fn ymdhms(&self, ts: Value, optional_args: &[Value]) -> Value
ymdhms(timestamp, infix=' ') — UTC YYYY-MM-DD<infix>HH:MM:SS.
Sourcepub fn rawencode(&self, params: Value, _optional_args: &[Value]) -> Value
pub fn rawencode(&self, params: Value, _optional_args: &[Value]) -> Value
rawencode(params, [doSeq]) — URL-encode without sorting.
rawencode(object) — qs.stringify(object, { encode: false }):
flat key=value pairs with no percent-encoding.
Sourcepub fn int_to_base16(&self, n: Value, _optional_args: &[Value]) -> Value
pub fn int_to_base16(&self, n: Value, _optional_args: &[Value]) -> Value
intToBase16(n) — int → lowercase hex string.
Sourcepub fn packb(&self, action: Value, _optional_args: &[Value]) -> Value
pub fn packb(&self, action: Value, _optional_args: &[Value]) -> Value
packb(action) — MessagePack pack stub. Hyperliquid signs the
packed bytes of an action. Returning empty bytes here is enough
to make the call compile; live signing won’t be correct.
packb(value) — MessagePack-encode a Value into a byte array.
Sourcepub fn eth_encode_structured_data(
&self,
domain: Value,
types: Value,
message: Value,
) -> Value
pub fn eth_encode_structured_data( &self, domain: Value, types: Value, message: Value, ) -> Value
ethEncodeStructuredData(domain, types, message) — EIP-712
encoding: returns the \x19\x01 || domainSeparator || structHash
preimage that the caller keccak-hashes before signing.
Sourcepub fn uuid22(&self, _optional_args: &[Value]) -> Value
pub fn uuid22(&self, _optional_args: &[Value]) -> Value
uuid22() — pseudo-random 22-char hex id.
Sourcepub fn uuid16(&self, _optional_args: &[Value]) -> Value
pub fn uuid16(&self, _optional_args: &[Value]) -> Value
uuid16() — pseudo-random 16-char hex id.
Sourcepub fn uuid(&self, _optional_args: &[Value]) -> Value
pub fn uuid(&self, _optional_args: &[Value]) -> Value
uuid() — pseudo-random UUID v4: xxxxxxxx-xxxx-4xxx-[89ab]xxx-xxxxxxxxxxxx.
Sourcepub fn urlencode(&self, params: Value, _optional_args: &[Value]) -> Value
pub fn urlencode(&self, params: Value, _optional_args: &[Value]) -> Value
urlencode(params) — wraps the typed urlencode_kv for Value args.
Sourcepub fn encode(&self, s: Value) -> Value
pub fn encode(&self, s: Value) -> Value
encode(s) — UTF-8 encode string to bytes (as Value::Array of ints).
pub fn number_to_string(&self, n: Value) -> Value
pub fn parse_number(&self, v: Value, optional_args: &[Value]) -> Value
pub fn parse_timeframe(&self, tf: Value) -> Value
Sourcepub fn precision_from_string(&self, s: Value) -> Value
pub fn precision_from_string(&self, s: Value) -> Value
precisionFromString(str) — ports functions/number.ts.
Scientific notation (1e-4 → 4, 1e4 → -4); otherwise the
number of fractional digits after stripping trailing zeros.
Sourcepub fn decimal_to_precision(
&self,
n: Value,
rounding: Value,
precision: Value,
optional_args: &[Value],
) -> Value
pub fn decimal_to_precision( &self, n: Value, rounding: Value, precision: Value, optional_args: &[Value], ) -> Value
decimalToPrecision(n, roundingMode, numPrecisionDigits, [countingMode], [paddingMode])
— faithful port of _decimalToPrecision from functions/number.ts.
pub fn capitalize(&self, s: Value) -> Value
pub fn encode_uri_component(&self, s: Value) -> Value
pub fn string_to_chars_array(&self, s: Value) -> Value
pub fn string_to_base64(&self, s: Value, _optional_args: &[Value]) -> Value
Sourcepub fn extract_params(&self, path: Value) -> Value
pub fn extract_params(&self, path: Value) -> Value
extract_params(path) — pulls {name} placeholders from a URL
template. Returns a Value::Array of names.
pub fn proxy_fn( &self, _url: Value, _method: Value, _headers: Value, _body: Value, ) -> Value
pub fn proxy_url_callback_fn( &self, _url: Value, _method: Value, _headers: Value, _body: Value, ) -> Value
pub fn http_proxy_callback_fn( &self, _url: Value, _method: Value, _headers: Value, _body: Value, ) -> Value
pub fn https_proxy_callback_fn( &self, _url: Value, _method: Value, _headers: Value, _body: Value, ) -> Value
pub fn socks_proxy_callback_fn( &self, _url: Value, _method: Value, _headers: Value, _body: Value, ) -> Value
pub fn ws_proxy_callback_fn( &self, _url: Value, _method: Value, _headers: Value, _body: Value, ) -> Value
pub fn wss_proxy_callback_fn( &self, _url: Value, _method: Value, _headers: Value, _body: Value, ) -> Value
pub fn ws_socks_proxy_callback_fn( &self, _url: Value, _method: Value, _headers: Value, _body: Value, ) -> Value
pub fn init_throttler(&mut self)
Sourcepub async fn throttle(&self, cost: &[Value]) -> Value
pub async fn throttle(&self, cost: &[Value]) -> Value
Leaky-bucket rate limiter, mirroring ts/src/base/functions/throttle.ts.
rateLimit is milliseconds-per-token, so refillRate = 1/rateLimit
tokens/ms; tokens may go negative (a request proceeds when tokens >= 0
and then subtracts its cost), and the next request waits until the bucket
refills back to zero. State lives in internals.throttle behind an async
mutex, so concurrent calls on one instance serialize (the TS single queue).
A no-op when enableRateLimit is false or the rate is effectively
unlimited.
pub fn resolve<T>(&self, v: T) -> T
pub fn reject(&self, err: ExchangeError) -> ExchangeError
Trait Implementations§
Source§impl DerivedExchange for BaseCore
impl DerivedExchange for BaseCore
fn parse_ticker(&self, _ticker: Value, _market: Value) -> Value
fn parse_trade(&self, _trade: Value, _market: Value) -> Value
fn parse_order(&self, _order: Value, _market: Value) -> Value
fn parse_market(&self, _market: Value) -> Value
fn parse_ohlcv(&self, _ohlcv: Value, _market: Value) -> Value
fn parse_order_book( &self, _ob: Value, _symbol: Value, _ts: Value, _bk: Value, _ak: Value, _pk: Value, _ak2: Value, _ck: Value, ) -> Value
fn parse_balance(&self, _response: Value) -> Value
fn parse_position(&self, _position: Value, _market: Value) -> Value
fn parse_funding_rate(&self, _rate: Value, _market: Value) -> Value
fn parse_deposit(&self, _tx: Value, _currency: Value) -> Value
fn parse_deposit_address(&self, _addr: Value, _currency: Value) -> Value
fn parse_last_price(&self, _entry: Value, _market: Value) -> Value
fn parse_withdrawal(&self, _tx: Value, _currency: Value) -> Value
fn parse_ledger_entry(&self, _entry: Value, _currency: Value) -> Value
fn parse_transfer(&self, _transfer: Value, _currency: Value) -> Value
fn parse_currency(&self, _currency: Value) -> Value
fn parse_bid_ask( &self, _bidask: Value, _price_key: Value, _amount_key: Value, _market: Value, ) -> Value
fn parse_open_interest(&self, _interest: Value, _market: Value) -> Value
fn parse_liquidation(&self, _liquidation: Value, _market: Value) -> Value
fn parse_funding_rate_history(&self, _entry: Value, _market: Value) -> Value
fn parse_margin_modification(&self, _data: Value, _market: Value) -> Value
fn parse_account(&self, _account: Value) -> Value
fn parse_my_trade(&self, _trade: Value, _market: Value) -> Value
fn parse_transaction(&self, _transaction: Value, _currency: Value) -> Value
fn parse_borrow_interest(&self, _info: Value, _market: Value) -> Value
fn parse_adl_rank(&self, _info: Value, _market: Value) -> Value
fn parse_income(&self, _info: Value, _market: Value) -> Value
fn parse_greeks(&self, _greeks: Value, _market: Value) -> Value
fn parse_margin_mode(&self, _margin_mode: Value, _market: Value) -> Value
fn parse_conversion( &self, _conversion: Value, _from_currency: Value, _to_currency: Value, ) -> Value
fn parse_borrow_rate(&self, _info: Value, _currency: Value) -> Value
fn parse_leverage(&self, _leverage: Value, _market: Value) -> Value
fn parse_market_leverage_tiers(&self, _info: Value, _market: Value) -> Value
fn parse_deposit_withdraw_fee(&self, _fee: Value, _currency: Value) -> Value
fn create_expired_option_market(&self, _symbol: Value) -> Value
fn parse_prediction_trade(&self, _trade: Value, _market: Value) -> Value
fn parse_prediction_order(&self, _order: Value, _market: Value) -> Value
fn parse_prediction_position(&self, _position: Value, _market: Value) -> Value
Source§fn nonce(&self) -> Value
fn nonce(&self) -> Value
nonce() — the request timestamp. The base default is seconds(), but
47 venues override it (binance: milliseconds() - timeDifference), and
without a slot here the override is invisible to any caller that reaches
the base through a trait method — notably a pro Core, which finds
ExchangeBase::nonce at deref step 0 and never looks at the REST
parent’s inherent one. Binance spot then signs its ws-api subscribe with
a seconds timestamp and the venue answers -1130.fn sign( &self, _path: Value, _api: Value, _method: Value, _params: Value, _headers: Value, _body: Value, ) -> Value
fn handle_errors( &self, _code: Value, _reason: Value, _url: Value, _method: Value, _headers: Value, _body: Value, _response: Value, _request_headers: Value, _request_body: Value, ) -> Value
Source§impl ExchangeBase for BaseCore
impl ExchangeBase for BaseCore
Source§fn call_dynamic<'a>(
&'a mut self,
method: &'a str,
args: Vec<Value>,
) -> Pin<Box<dyn Future<Output = Value> + Send + 'a>>
fn call_dynamic<'a>( &'a mut self, method: &'a str, args: Vec<Value>, ) -> Pin<Box<dyn Future<Output = Value> + Send + 'a>>
call_dynamic_base for base-only methods.
The single required method — every override reaches the core statically.Source§fn dispatch_to_derived<'a>(
&'a mut self,
method: &'a str,
args: Vec<Value>,
) -> Pin<Box<dyn Future<Output = Option<Value>> + Send + 'a>>
fn dispatch_to_derived<'a>( &'a mut self, method: &'a str, args: Vec<Value>, ) -> Pin<Box<dyn Future<Output = Option<Value>> + Send + 'a>>
method(args) to the derived override by name, with a per-method
re-entry guard (so a base method calling its own name falls through to
the base body instead of looping). Replaces Exchange::dispatch_to_derived
— no stored pointer; call_dynamic is a static trait call.Source§fn is_dictionary(&self, value: Value) -> Value
fn is_dictionary(&self, value: Value) -> Value
isDictionary(value) — hand-provided base method. The ast-transpiler
drops Exchange.ts’s typeof value === 'object' body, so supply it here
as a trait default reachable by every Core (used across the base +
derived exchanges).fn describe(&self) -> Value
fn clean_rest_data(&mut self)
fn clean_ws_data(&mut self)
fn safe_bool_n( &self, dictionaryOrList: Value, keys: Value, optional_args: &[Value], ) -> Value
fn safe_bool2( &self, dictionaryOrList: Value, key1: Value, key2: Value, optional_args: &[Value], ) -> Value
fn safe_bool( &self, dictionaryOrList: Value, key: Value, optional_args: &[Value], ) -> Value
fn safe_dict_n( &self, dictionaryOrList: Value, keys: Value, optional_args: &[Value], ) -> Value
fn safe_dict( &self, dictionaryOrList: Value, key: Value, optional_args: &[Value], ) -> Value
fn safe_dict2( &self, dictionaryOrList: Value, key1: Value, key2: Value, optional_args: &[Value], ) -> Value
fn safe_list_n( &self, dictionaryOrList: Value, keys: Value, optional_args: &[Value], ) -> Value
fn safe_list2( &self, dictionaryOrList: Value, key1: Value, key2: Value, optional_args: &[Value], ) -> Value
fn safe_list( &self, dictionaryOrList: Value, key: Value, optional_args: &[Value], ) -> Value
fn store_by_key(&self, dict: Value, key: Value, value: Value)
fn handle_deltas(&self, bookside: Value, deltas: Value)
fn handle_delta(&self, bookside: Value, delta: Value)
fn handle_book_deltas(&self, orderbook: Value, deltas: Value)
fn handle_book_delta(&self, orderbook: Value, delta: Value)
fn handle_deltas_with_keys( &self, bookSide: Value, deltas: Value, optional_args: &[Value], )
fn get_cache_index(&self, orderbook: Value, deltas: Value) -> Value
fn arrays_concat(&self, arraysOfArrays: Value) -> Value
fn find_timeframe(&self, timeframe: Value, optional_args: &[Value]) -> Value
fn check_proxy_url_settings(&self, optional_args: &[Value]) -> Value
fn url_encoder_for_proxy_url(&self, targetUrl: Value) -> Value
fn check_proxy_settings(&self, optional_args: &[Value]) -> Value
fn check_ws_proxy_settings(&self) -> Value
fn check_conflicting_proxies(&self, proxyAgentSet: Value, proxyUrlSet: Value)
fn check_address(&self, optional_args: &[Value]) -> Value
fn find_message_hashes(&self, client: Value, element: Value) -> Value
fn filter_by_limit(&self, array: Value, optional_args: &[Value]) -> Value
fn filter_by_since_limit(&self, array: Value, optional_args: &[Value]) -> Value
fn filter_by_value_since_limit( &self, array: Value, field: Value, optional_args: &[Value], ) -> Value
fn set_sandbox_mode(&mut self, enabled: Value)
fn enable_demo_trading(&mut self, enable: Value)
fn sign(&self, path: Value, optional_args: &[Value]) -> Value
fn fetch_accounts( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_liquidations( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_liquidations_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_my_liquidations( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_my_liquidations_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_trades( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_trades_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_ohlcv_for_symbols( &mut self, symbolsAndTimeframes: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_ohlcv_for_symbols( &mut self, symbolsAndTimeframes: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_order_book_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_positions( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_ticker( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_mark_price( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_mark_prices( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_deposit_addresses( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_margin_mode( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_margin_modes( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_order_book( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_time( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_trading_limits( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn parse_currency(&self, rawCurrency: Value) -> Value
fn parse_currencies(&self, rawCurrencies: Value) -> Value
fn parse_market(&self, market: Value) -> Value
fn parse_markets(&self, markets: Value) -> Value
fn parse_ticker(&self, ticker: Value, optional_args: &[Value]) -> Value
fn parse_deposit_address( &self, depositAddress: Value, optional_args: &[Value], ) -> Value
fn parse_trade(&self, trade: Value, optional_args: &[Value]) -> Value
fn parse_transaction( &self, transaction: Value, optional_args: &[Value], ) -> Value
fn parse_transfer(&self, transfer: Value, optional_args: &[Value]) -> Value
fn parse_account(&self, account: Value) -> Value
fn parse_ledger_entry(&self, item: Value, optional_args: &[Value]) -> Value
fn parse_order(&self, order: Value, optional_args: &[Value]) -> Value
fn fetch_cross_borrow_rates( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_isolated_borrow_rates( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn parse_market_leverage_tiers( &self, info: Value, optional_args: &[Value], ) -> Value
fn fetch_leverage_tiers( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn parse_position(&self, position: Value, optional_args: &[Value]) -> Value
fn parse_funding_rate_history( &self, info: Value, optional_args: &[Value], ) -> Value
fn parse_borrow_interest(&self, info: Value, optional_args: &[Value]) -> Value
fn parse_isolated_borrow_rate( &self, info: Value, optional_args: &[Value], ) -> Value
fn parse_ws_trade(&self, trade: Value, optional_args: &[Value]) -> Value
fn parse_ws_order(&self, order: Value, optional_args: &[Value]) -> Value
fn parse_ws_order_trade(&self, trade: Value, optional_args: &[Value]) -> Value
fn parse_ws_ohlcv(&self, ohlcv: Value, optional_args: &[Value]) -> Value
fn fetch_funding_rates( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_funding_intervals( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_funding_rate( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_funding_rates( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_funding_rates( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_funding_rates_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn transfer( &mut self, code: Value, amount: Value, fromAccount: Value, toAccount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn withdraw( &mut self, code: Value, amount: Value, address: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_deposit_address( &mut self, code: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn set_leverage( &mut self, leverage: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_leverage( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_leverages( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn set_position_mode( &mut self, hedged: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn add_margin( &mut self, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn reduce_margin( &mut self, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn set_margin( &mut self, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_long_short_ratio( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_long_short_ratio_history( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_margin_adjustment_history( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn set_margin_mode( &mut self, marginMode: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_deposit_addresses_by_network( &mut self, code: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_open_interest_history( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_open_interests( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn sign_in( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_payment_methods( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn parse_to_int(&self, number: Value) -> Value
fn parse_to_numeric(&self, number: Value) -> Value
fn is_round_number(&self, value: Value) -> Value
fn is_empty_string(&self, value: Value) -> Value
fn safe_number_omit_zero( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
fn safe_integer_omit_zero( &self, obj: Value, key: Value, optional_args: &[Value], ) -> Value
fn after_construct(&mut self)
fn init_rest_rate_limiter(&mut self)
fn features_generator(&mut self)
fn features_mapper( &mut self, initialFeatures: Value, marketType: Value, optional_args: &[Value], ) -> Value
fn feature_value(&self, symbol: Value, optional_args: &[Value]) -> Value
fn feature_value_by_type( &self, marketType: Value, subType: Value, optional_args: &[Value], ) -> Value
fn orderbook_checksum_message(&self, symbol: Value) -> Value
fn create_networks_by_id_object(&mut self)
fn get_default_options(&self) -> Value
fn safe_ledger_entry(&self, entry: Value, optional_args: &[Value]) -> Value
fn safe_currency_structure(&self, currency: Value) -> Value
fn safe_market_structure(&self, optional_args: &[Value]) -> Value
fn set_markets(&mut self, markets: Value, optional_args: &[Value]) -> Value
fn set_markets_from_exchange(&mut self, sourceExchange: Value) -> Value
fn get_describe_for_extended_ws_exchange( &self, currentRestInstance: Value, parentRestInstance: Value, wsBaseDescribe: Value, ) -> Value
fn safe_balance(&self, balance: Value) -> Value
fn safe_order(&self, order: Value, optional_args: &[Value]) -> Value
fn parse_orders(&self, orders: Value, optional_args: &[Value]) -> Value
fn calculate_fee_with_rate( &self, symbol: Value, type_var: Value, side: Value, amount: Value, price: Value, optional_args: &[Value], ) -> Value
fn calculate_fee( &self, symbol: Value, type_var: Value, side: Value, amount: Value, price: Value, optional_args: &[Value], ) -> Value
fn safe_liquidation(&self, liquidation: Value, optional_args: &[Value]) -> Value
fn safe_trade(&self, trade: Value, optional_args: &[Value]) -> Value
fn create_ccxt_trade_id(&self, optional_args: &[Value]) -> Value
fn parsed_fee_and_fees(&self, container: Value) -> Value
fn parse_fee_numeric(&self, fee: Value) -> Value
fn find_nearest_ceiling(&self, arr: Value, providedValue: Value) -> Value
fn add_key_in_array_items(&self, obj: Value, keyName: Value) -> Value
fn invert_flat_string_dictionary(&self, dict: Value) -> Value
fn string_to_base16(&self, str_val: Value) -> Value
fn reduce_fees_by_currency(&self, fees: Value) -> Value
fn safe_ticker(&self, ticker: Value, optional_args: &[Value]) -> Value
fn fetch_borrow_rate( &mut self, code: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn repay_cross_margin( &mut self, code: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn repay_isolated_margin( &mut self, symbol: Value, code: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn borrow_cross_margin( &mut self, code: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn borrow_isolated_margin( &mut self, symbol: Value, code: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn borrow_margin( &mut self, code: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn repay_margin( &mut self, code: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_ohlcv( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_spot_ohlcv( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_contract_ohlcv( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_ohlcv_ws( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_ohlcv( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn convert_trading_view_to_ohlcv( &self, ohlcvs: Value, optional_args: &[Value], ) -> Value
fn convert_ohlcv_to_trading_view( &self, ohlcvs: Value, optional_args: &[Value], ) -> Value
fn fetch_web_endpoint( &mut self, method: Value, endpointMethod: Value, returnAsJson: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn market_ids(&self, optional_args: &[Value]) -> Value
fn currency_ids(&self, optional_args: &[Value]) -> Value
fn markets_for_symbols(&self, optional_args: &[Value]) -> Value
fn market_symbols(&self, optional_args: &[Value]) -> Value
fn market_codes(&self, optional_args: &[Value]) -> Value
fn parse_order_book_bids_asks( &self, bidasks: Value, optional_args: &[Value], ) -> Value
fn filter_by_key( &self, objects: Value, key: Value, optional_args: &[Value], ) -> Value
fn filter_by_symbol(&self, objects: Value, optional_args: &[Value]) -> Value
fn parse_ohlcv(&self, ohlcv: Value, optional_args: &[Value]) -> Value
fn safe_network(&self, network: Value) -> Value
fn prioritized_network_aliases(&self, optional_args: &[Value]) -> Value
fn network_code_to_id( &self, networkCode: Value, optional_args: &[Value], ) -> Value
fn network_id_to_code(&self, optional_args: &[Value]) -> Value
fn handle_network_code_and_params(&self, params: Value) -> Value
fn default_network_code(&self, currencyCode: Value) -> Value
fn select_network_code_from_unified_networks( &self, currencyCode: Value, networkCode: Value, indexedNetworkEntries: Value, ) -> Value
fn select_network_id_from_raw_networks( &self, currencyCode: Value, networkCode: Value, indexedNetworkEntries: Value, ) -> Value
fn select_network_key_from_networks( &self, currencyCode: Value, networkCode: Value, indexedNetworkEntries: Value, optional_args: &[Value], ) -> Value
fn safe_number2( &self, dictionary: Value, key1: Value, key2: Value, optional_args: &[Value], ) -> Value
fn parse_order_book( &self, orderbook: Value, symbol: Value, optional_args: &[Value], ) -> Value
fn parse_ohlc_vs(&self, ohlcvs: Value, optional_args: &[Value]) -> Value
fn parse_leverage_tiers( &self, response: Value, optional_args: &[Value], ) -> Value
fn load_trading_limits( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn safe_position(&self, position: Value) -> Value
fn parse_positions(&self, positions: Value, optional_args: &[Value]) -> Value
fn parse_adl_rank(&self, info: Value, optional_args: &[Value]) -> Value
fn parse_adl_ranks(&self, ranks: Value, optional_args: &[Value]) -> Value
fn parse_accounts(&self, accounts: Value, optional_args: &[Value]) -> Value
fn parse_trades_helper( &self, isWs: Value, trades: Value, optional_args: &[Value], ) -> Value
fn parse_trades(&self, trades: Value, optional_args: &[Value]) -> Value
fn parse_ws_trades(&self, trades: Value, optional_args: &[Value]) -> Value
fn parse_transactions( &self, transactions: Value, optional_args: &[Value], ) -> Value
fn parse_transfers(&self, transfers: Value, optional_args: &[Value]) -> Value
fn parse_ledger(&self, data: Value, optional_args: &[Value]) -> Value
fn nonce(&self) -> Value
fn incrementing_nonce(&mut self) -> Value
fn set_headers(&self, headers: Value) -> Value
fn currency_id(&self, code: Value) -> Value
fn market_id(&self, symbol: Value) -> Value
fn symbol(&self, symbol: Value) -> Value
fn handle_param_string( &self, params: Value, paramName: Value, optional_args: &[Value], ) -> Value
fn handle_param_string2( &self, params: Value, paramName1: Value, paramName2: Value, optional_args: &[Value], ) -> Value
fn handle_param_integer( &self, params: Value, paramName: Value, optional_args: &[Value], ) -> Value
fn handle_param_integer2( &self, params: Value, paramName1: Value, paramName2: Value, optional_args: &[Value], ) -> Value
fn handle_param_bool( &self, params: Value, paramName: Value, optional_args: &[Value], ) -> Value
fn handle_param_bool2( &self, params: Value, paramName1: Value, paramName2: Value, optional_args: &[Value], ) -> Value
fn handle_request_network( &self, params: Value, request: Value, exchangeSpecificKey: Value, optional_args: &[Value], ) -> Value
fn resolve_path(&self, path: Value, params: Value) -> Value
fn get_list_from_object_values(&self, objects: Value, key: Value) -> Value
fn get_symbols_for_market_type(&self, optional_args: &[Value]) -> Value
fn filter_by_array( &self, objects: Value, key: Value, optional_args: &[Value], ) -> Value
fn filter_out_by_array( &self, objects: Value, key: Value, optional_args: &[Value], ) -> Value
fn fetch2( &mut self, path: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn request( &mut self, path: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn load_accounts( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn build_ohlcvc(&self, trades: Value, optional_args: &[Value]) -> Value
fn parse_trading_view_ohlcv( &self, ohlcvs: Value, optional_args: &[Value], ) -> Value
fn fetch_borrow_interest( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_ledger( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_ledger_entry( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn parse_order_book_bid_ask( &self, bidask: Value, optional_args: &[Value], ) -> Value
fn safe_currency(&self, currencyId: Value, optional_args: &[Value]) -> Value
fn safe_market(&self, optional_args: &[Value]) -> Value
fn market_or_null(&self, optional_args: &[Value]) -> Value
fn check_required_credentials(&self, optional_args: &[Value]) -> Value
fn oath(&self) -> Value
fn fetch_balance( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_balance_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn parse_balance(&self, response: Value) -> Value
fn watch_balance( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_partial_balance( &mut self, part: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_free_balance( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_used_balance( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_total_balance( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_status( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_transaction_fee( &mut self, code: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_transaction_fees( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_deposit_withdraw_fees( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_deposit_withdraw_fee( &mut self, code: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn get_supported_mapping(&self, key: Value, optional_args: &[Value]) -> Value
fn fetch_cross_borrow_rate( &mut self, code: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_isolated_borrow_rate( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn require_value(&self, value: Value, optional_args: &[Value]) -> Value
fn handle_option_and_params( &self, params: Value, methodName: Value, optionName: Value, optional_args: &[Value], ) -> Value
fn handle_option_and_params2( &self, params: Value, methodName1: Value, optionName1: Value, optionName2: Value, optional_args: &[Value], ) -> Value
fn handle_option_string_and_params( &self, params: Value, methodName: Value, optionName: Value, optional_args: &[Value], ) -> Value
fn handle_option_string_and_params2( &self, params: Value, methodName: Value, optionName1: Value, optionName2: Value, optional_args: &[Value], ) -> Value
fn handle_option_bool_and_params( &self, params: Value, methodName: Value, optionName: Value, optional_args: &[Value], ) -> Value
fn handle_option_bool_and_params2( &self, params: Value, methodName: Value, optionName1: Value, optionName2: Value, optional_args: &[Value], ) -> Value
fn handle_option_integer_and_params( &self, params: Value, methodName: Value, optionName: Value, optional_args: &[Value], ) -> Value
fn handle_option_integer_and_params2( &self, params: Value, methodName: Value, optionName1: Value, optionName2: Value, optional_args: &[Value], ) -> Value
fn handle_option( &self, methodName: Value, optionName: Value, optional_args: &[Value], ) -> Value
fn handle_market_type_and_params( &self, methodName: Value, optional_args: &[Value], ) -> Value
fn handle_sub_type_and_params( &self, methodName: Value, optional_args: &[Value], ) -> Value
fn handle_margin_mode_and_params( &self, methodName: Value, optional_args: &[Value], ) -> Value
fn throw_exactly_matched_exception( &self, exact: Value, string: Value, message: Value, )
fn throw_broadly_matched_exception( &self, broad: Value, string: Value, message: Value, )
fn find_broadly_matched_key(&self, broad: Value, string: Value) -> Value
fn handle_errors( &self, statusCode: Value, statusText: Value, url: Value, method: Value, responseHeaders: Value, responseBody: Value, response: Value, requestHeaders: Value, requestBody: Value, ) -> Value
fn calculate_rate_limiter_cost( &self, api: Value, method: Value, path: Value, params: Value, optional_args: &[Value], ) -> Value
fn fetch_spot_tickers( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_contract_tickers( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_order_books( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_tickers( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_funding_rate( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_twap_order( &mut self, symbol: Value, side: Value, amount: Value, duration: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_convert_trade( &mut self, id: Value, fromCode: Value, toCode: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_convert_trade( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_convert_trade_history( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_position_mode( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_adl_rank( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_positions_adl_rank( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_position_adl_rank( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn set_take_profit_and_stop_loss_params( &self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> Value
fn create_spot_orders( &mut self, orders: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_contract_orders( &mut self, orders: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_spot_order( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_contract_order( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_all_spot_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_all_contract_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_all_orders_after( &mut self, timeout: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_orders_for_symbols( &mut self, orders: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_my_liquidations( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_liquidations( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_greeks( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_all_greeks( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_option_chain( &mut self, code: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_option( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_convert_quote( &mut self, fromCode: Value, toCode: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_deposits_withdrawals( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_deposits( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_withdrawals( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_deposits_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_withdrawals_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_funding_rate_history( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_funding_history( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn parse_last_price(&self, price: Value, optional_args: &[Value]) -> Value
fn fetch_deposit_address( &mut self, code: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_contract_deposit_address( &mut self, code: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn account(&self) -> Value
fn merge_balance_account( &self, result: Value, code: Value, account: Value, ) -> Value
fn common_currency_code(&self, code: Value) -> Value
fn currency(&self, code: Value) -> Value
fn market(&self, symbol: Value) -> Value
fn create_expired_option_market(&self, symbol: Value) -> Value
fn is_leveraged_currency( &self, currencyCode: Value, optional_args: &[Value], ) -> Value
fn handle_withdraw_tag_and_params(&self, tag: Value, params: Value) -> Value
fn cost_to_precision(&self, symbol: Value, cost: Value) -> Value
fn price_to_precision(&self, symbol: Value, price: Value) -> Value
fn amount_to_precision(&self, symbol: Value, amount: Value) -> Value
fn fee_to_precision(&self, symbol: Value, fee: Value) -> Value
fn currency_to_precision( &self, code: Value, fee: Value, optional_args: &[Value], ) -> Value
fn force_string(&self, value: Value) -> Value
fn is_tick_precision(&self) -> Value
fn is_significant_precision(&self) -> Value
fn safe_number(&self, obj: Value, key: Value, optional_args: &[Value]) -> Value
fn safe_number_n( &self, obj: Value, arr: Value, optional_args: &[Value], ) -> Value
fn parse_precision(&self, optional_args: &[Value]) -> Value
fn integer_precision_to_amount(&self, precision: Value) -> Value
fn load_time_difference( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn implode_hostname(&self, url: Value) -> Value
fn fetch_market_leverage_tiers( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_sub_account( &mut self, name: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn safe_currency_code( &self, currencyId: Value, optional_args: &[Value], ) -> Value
fn filter_by_symbol_since_limit( &self, array: Value, optional_args: &[Value], ) -> Value
fn filter_by_currency_since_limit( &self, array: Value, optional_args: &[Value], ) -> Value
fn filter_by_symbols_since_limit( &self, array: Value, optional_args: &[Value], ) -> Value
fn parse_last_prices(&self, pricesData: Value, optional_args: &[Value]) -> Value
fn parse_tickers(&self, tickers: Value, optional_args: &[Value]) -> Value
fn parse_deposit_addresses( &self, addresses: Value, optional_args: &[Value], ) -> Value
fn parse_borrow_interests( &self, response: Value, optional_args: &[Value], ) -> Value
fn parse_borrow_rate(&self, info: Value, optional_args: &[Value]) -> Value
fn parse_borrow_rate_history( &self, response: Value, code: Value, since: Value, limit: Value, ) -> Value
fn parse_isolated_borrow_rates(&self, info: Value) -> Value
fn parse_funding_rate_histories( &self, response: Value, optional_args: &[Value], ) -> Value
fn safe_symbol(&self, marketId: Value, optional_args: &[Value]) -> Value
fn parse_funding_rate(&self, contract: Value, optional_args: &[Value]) -> Value
fn parse_funding_rates(&self, response: Value, optional_args: &[Value]) -> Value
fn parse_long_short_ratio(&self, info: Value, optional_args: &[Value]) -> Value
fn parse_long_short_ratio_history( &self, response: Value, optional_args: &[Value], ) -> Value
fn handle_trigger_prices_and_params( &self, symbol: Value, params: Value, optional_args: &[Value], ) -> Value
fn handle_trigger_direction_and_params( &self, params: Value, optional_args: &[Value], ) -> Value
fn handle_trigger_and_params(&self, params: Value) -> Value
fn is_trigger_order(&self, params: Value) -> Value
fn is_post_only( &self, isMarketOrder: Value, exchangeSpecificParam: Value, optional_args: &[Value], ) -> Value
fn handle_post_only( &self, isMarketOrder: Value, exchangeSpecificPostOnlyOption: Value, optional_args: &[Value], ) -> Value
fn fetch_last_prices( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_trading_fees( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_trading_fees_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_convert_currencies( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn parse_open_interest(&self, interest: Value, optional_args: &[Value]) -> Value
fn parse_open_interests( &self, response: Value, optional_args: &[Value], ) -> Value
fn parse_open_interests_history( &self, response: Value, optional_args: &[Value], ) -> Value
fn fetch_funding_rate( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_funding_interval( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_mark_ohlcv( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_index_ohlcv( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn handle_time_in_force(&self, optional_args: &[Value]) -> Value
fn convert_type_to_account(&self, account: Value) -> Value
fn check_required_argument( &self, methodName: Value, argument: Value, argumentName: Value, optional_args: &[Value], )
fn check_required_margin_argument( &self, methodName: Value, symbol: Value, marginMode: Value, )
fn parse_deposit_withdraw_fees( &self, response: Value, optional_args: &[Value], ) -> Value
fn parse_deposit_withdraw_fee( &self, fee: Value, optional_args: &[Value], ) -> Value
fn deposit_withdraw_fee(&self, info: Value) -> Value
fn assign_default_deposit_withdraw_fees( &self, fee: Value, optional_args: &[Value], ) -> Value
fn parse_income(&self, info: Value, optional_args: &[Value]) -> Value
fn parse_incomes(&self, incomes: Value, optional_args: &[Value]) -> Value
fn get_market_from_symbols(&self, optional_args: &[Value]) -> Value
fn parse_ws_ohlc_vs(&self, ohlcvs: Value, optional_args: &[Value]) -> Value
fn fetch_transactions( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn filter_by_array_positions( &self, objects: Value, key: Value, optional_args: &[Value], ) -> Value
fn filter_by_array_tickers( &self, objects: Value, key: Value, optional_args: &[Value], ) -> Value
fn filter_by_array_adl_ranks( &self, objects: Value, key: Value, optional_args: &[Value], ) -> Value
fn create_ohlcv_object( &self, symbol: Value, timeframe: Value, data: Value, ) -> Value
fn handle_max_entries_per_request_and_params( &self, method: Value, optional_args: &[Value], ) -> Value
fn fetch_paginated_call_dynamic( &mut self, method: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn safe_deterministic_call( &mut self, method: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_paginated_call_deterministic( &mut self, method: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_paginated_call_cursor( &mut self, method: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_paginated_call_incremental( &mut self, method: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn sort_cursor_paginated_result(&self, result: Value) -> Value
fn remove_repeated_elements_from_array( &self, input: Value, optional_args: &[Value], ) -> Value
fn remove_repeated_trades_from_array(&self, input: Value) -> Value
fn remove_keys_from_dict(&self, dict: Value, removeKeys: Value) -> Value
fn handle_until_option( &self, key: Value, request: Value, params: Value, optional_args: &[Value], ) -> Value
fn safe_open_interest(&self, interest: Value, optional_args: &[Value]) -> Value
fn parse_liquidation( &self, liquidation: Value, optional_args: &[Value], ) -> Value
fn parse_liquidations( &self, liquidations: Value, optional_args: &[Value], ) -> Value
fn parse_greeks(&self, greeks: Value, optional_args: &[Value]) -> Value
fn parse_all_greeks(&self, greeks: Value, optional_args: &[Value]) -> Value
fn parse_option(&self, chain: Value, optional_args: &[Value]) -> Value
fn parse_option_chain(&self, response: Value, optional_args: &[Value]) -> Value
fn parse_margin_modes(&self, response: Value, optional_args: &[Value]) -> Value
fn parse_margin_mode(&self, marginMode: Value, optional_args: &[Value]) -> Value
fn parse_leverages(&self, response: Value, optional_args: &[Value]) -> Value
fn parse_leverage(&self, leverage: Value, optional_args: &[Value]) -> Value
fn parse_conversions( &self, conversions: Value, optional_args: &[Value], ) -> Value
fn parse_conversion(&self, conversion: Value, optional_args: &[Value]) -> Value
fn convert_expire_date(&self, date: Value) -> Value
fn convert_expire_date_to_market_id_date(&self, date: Value) -> Value
fn convert_market_id_expire_date(&self, date: Value) -> Value
fn load_markets_and_sign_in(&mut self) -> impl Future<Output = Value> + Send
fn parse_margin_modification( &self, data: Value, optional_args: &[Value], ) -> Value
fn parse_margin_modifications( &self, response: Value, optional_args: &[Value], ) -> Value
fn fetch_transfer( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_transfers( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_ohlcv( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn withdraw_ws( &mut self, code: Value, amount: Value, address: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_my_trades( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_orders_by_status_ws( &mut self, status: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn un_watch_bids_asks( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn clean_unsubscription( &self, client: Value, subHash: Value, unsubHash: Value, optional_args: &[Value], )
fn clean_cache(&mut self, subscription: Value)
fn timeframe_from_milliseconds(&self, ms: Value) -> Value
fn is_uta_enabled( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn close_position( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn close_all_positions( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn edit_orders( &mut self, orders: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_canceled_and_closed_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_position_history( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_positions_history( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_positions_risk( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_positions_for_symbol( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_positions_for_symbol_ws( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_position( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_my_trades_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_trades_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_bids_asks( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_mark_price( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_mark_prices( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_bids_asks( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_mark_price( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_mark_prices( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_l3_order_book( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_order_book_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_orders_for_symbols( &mut self, symbols: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_all_orders_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_order_ws( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_orders_ws( &mut self, ids: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_limit_buy_order_ws( &mut self, symbol: Value, amount: Value, price: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_limit_order_ws( &mut self, symbol: Value, side: Value, amount: Value, price: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_limit_sell_order_ws( &mut self, symbol: Value, amount: Value, price: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_buy_order_ws( &mut self, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_order_with_cost_ws( &mut self, symbol: Value, side: Value, cost: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_order_ws( &mut self, symbol: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_sell_order_ws( &mut self, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_order_with_take_profit_and_stop_loss_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_orders_ws( &mut self, orders: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_post_only_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_reduce_only_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_stop_limit_order_ws( &mut self, symbol: Value, side: Value, amount: Value, price: Value, triggerPrice: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_stop_loss_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_stop_market_order_ws( &mut self, symbol: Value, side: Value, amount: Value, triggerPrice: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_stop_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_take_profit_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_trailing_amount_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_trailing_percent_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_trigger_order_ws( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn edit_order_ws( &mut self, id: Value, symbol: Value, type_var: Value, side: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_closed_orders_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_my_trades_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_open_orders_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_order_book_ws( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_order_ws( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_orders_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_position_ws( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_positions_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_ticker_ws( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_tickers_ws( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_trades_ws( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_trades( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_trades( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_order_book( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_rest_order_book_safe( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_order_book( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_open_interest( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_l2_order_book( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn edit_limit_buy_order( &mut self, id: Value, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn edit_limit_sell_order( &mut self, id: Value, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn edit_limit_order( &mut self, id: Value, symbol: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn edit_order( &mut self, id: Value, symbol: Value, type_var: Value, side: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn edit_order_with_client_order_id( &mut self, clientOrderId: Value, symbol: Value, type_var: Value, side: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_position( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_positions( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_position_for_symbols( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_positions( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_ticker( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_ticker( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_tickers( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_tickers( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_order( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_order_with_client_order_id( &mut self, clientOrderId: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_order_status( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_unified_order( &mut self, order: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_trailing_amount_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_trailing_percent_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_order_with_cost( &mut self, symbol: Value, side: Value, cost: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_buy_order_with_cost( &mut self, symbol: Value, cost: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_sell_order_with_cost( &mut self, symbol: Value, cost: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_trigger_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_stop_loss_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_take_profit_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_order_with_take_profit_and_stop_loss( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_orders( &mut self, orders: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_order( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_order_with_client_order_id( &mut self, clientOrderId: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_orders( &mut self, ids: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_orders_with_client_order_ids( &mut self, clientOrderIds: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_all_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn cancel_unified_order( &mut self, order: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_order_trades( &mut self, id: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_open_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_closed_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_canceled_orders( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_my_trades( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_my_trades( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_limit_order( &mut self, symbol: Value, side: Value, amount: Value, price: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_order( &mut self, symbol: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_limit_buy_order( &mut self, symbol: Value, amount: Value, price: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_limit_sell_order( &mut self, symbol: Value, amount: Value, price: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_buy_order( &mut self, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_market_sell_order( &mut self, symbol: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_post_only_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_reduce_only_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_stop_order( &mut self, symbol: Value, type_var: Value, side: Value, amount: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_stop_limit_order( &mut self, symbol: Value, side: Value, amount: Value, price: Value, triggerPrice: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn create_stop_market_order( &mut self, symbol: Value, side: Value, amount: Value, triggerPrice: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_trading_fee( &mut self, symbol: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
Auto Trait Implementations§
impl !RefUnwindSafe for BaseCore
impl !UnwindSafe for BaseCore
impl Freeze for BaseCore
impl Send for BaseCore
impl Sync for BaseCore
impl Unpin for BaseCore
impl UnsafeUnpin for BaseCore
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CallDynamicChecked for Twhere
T: ExchangeBase,
impl<T> CallDynamicChecked for Twhere
T: ExchangeBase,
Source§impl<T> ExchangeRuntime for Twhere
T: ExchangeBase,
impl<T> ExchangeRuntime for Twhere
T: ExchangeBase,
fn fetch( &mut self, url: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
Source§fn ws_run(
&mut self,
url: String,
hashes: Vec<String>,
message: Value,
subscribe_hashes: Vec<String>,
subscription: Value,
) -> impl Future<Output = Value> + Send
fn ws_run( &mut self, url: String, hashes: Vec<String>, message: Value, subscribe_hashes: Vec<String>, subscription: Value, ) -> impl Future<Output = Value> + Send
watch / watch_multiple.Source§fn ws_drive_loop(
&mut self,
client: Arc<ClientState>,
hashes: Vec<String>,
url: String,
) -> impl Future<Output = Value> + Send
fn ws_drive_loop( &mut self, client: Arc<ClientState>, hashes: Vec<String>, url: String, ) -> impl Future<Output = Value> + Send
ws_run can wrap it in the
WS_DRIVEN_URLS task-local scope.Source§fn ws_load_order_book(
&mut self,
args: Vec<Value>,
) -> impl Future<Output = ()> + Send
fn ws_load_order_book( &mut self, args: Vec<Value>, ) -> impl Future<Output = ()> + Send
loadOrderBook: fetch the REST depth snapshot, splice the buffered
WS cache onto it, and resolve the watcher. Venues spawn this after
buffering enough deltas (bitstamp, …). Runs in the drive loop so it can
reach the venue’s get_cache_index / handle_deltas overrides.fn watch( &mut self, url: Value, message_hash: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn watch_multiple( &mut self, url: Value, message_hashes: Value, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fn fetch_typed( &mut self, url: &str, method: &str, headers: HashMap<String, String>, body: Option<String>, ) -> impl Future<Output = Result<Value>> + Send
fn request_typed( &mut self, path: &str, scope_segments: &[String], verb: &str, params: Value, cost: Value, ) -> impl Future<Output = Result<Value>> + Send
Source§fn implicit_api_call(
&mut self,
name: &str,
params: Value,
) -> impl Future<Output = Result<Value>> + Send
fn implicit_api_call( &mut self, name: &str, params: Value, ) -> impl Future<Output = Result<Value>> + Send
request_typed.Source§fn call_method(
&mut self,
name: Value,
args: &[Value],
) -> impl Future<Output = Value> + Send
fn call_method( &mut self, name: Value, args: &[Value], ) -> impl Future<Output = Value> + Send
_api.rs).Source§fn load_markets(
&mut self,
optional_args: &[Value],
) -> impl Future<Output = Value> + Send
fn load_markets( &mut self, optional_args: &[Value], ) -> impl Future<Output = Value> + Send
fetch_markets /
fetch_currencies / set_markets to the derived overrides.