aljaz/bitfinex-api-py
1
0
Fork 0
mirror of https://github.com/aljazceru/bitfinex-api-py.git synced 2025-12-20 07:14:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #24 from Davi0kProgramsThings/fix/refactoring

Browse Source 
Merge branch `fix/refactoring` into branch `feature/rest`.
This commit is contained in:
Davide Casale
2023-01-27 17:24:43 +01:00
committed by Davide Casale
parent 48433fbb01 2fc31db7a3
commit a924721bbe
19 changed files with 1645 additions and 1580 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
bfxapi/notification.py
View File

@@ -8,16 +8,16 @@ T = TypeVar("T")
@dataclass @dataclass
class Notification(_Type, Generic[T]): class Notification(_Type, Generic[T]):
MTS: int mts: int
TYPE: str type: str
MESSAGE_ID: Optional[int] message_id: Optional[int]
NOTIFY_INFO: T notify_info: T
CODE: Optional[int] code: Optional[int]
STATUS: str status: str
TEXT: str text: str
class _Notification(_Serializer, Generic[T]): class _Notification(_Serializer, Generic[T]):
__LABELS = [ "MTS", "TYPE", "MESSAGE_ID", "_PLACEHOLDER", "NOTIFY_INFO", "CODE", "STATUS", "TEXT" ] __LABELS = [ "mts", "type", "message_id", "_PLACEHOLDER", "notify_info", "code", "status", "text" ]
def __init__(self, serializer: Optional[_Serializer] = None, iterate: bool = False): def __init__(self, serializer: Optional[_Serializer] = None, iterate: bool = False):
super().__init__("Notification", Notification, _Notification.__LABELS, IGNORE = [ "_PLACEHOLDER" ]) super().__init__("Notification", Notification, _Notification.__LABELS, IGNORE = [ "_PLACEHOLDER" ])
@@ -28,13 +28,13 @@ class _Notification(_Serializer, Generic[T]):
notification = cast(Notification[T], Notification(**dict(self._serialize(*values)))) notification = cast(Notification[T], Notification(**dict(self._serialize(*values))))
if isinstance(self.serializer, _Serializer): if isinstance(self.serializer, _Serializer):
NOTIFY_INFO = cast(List[Any], notification.NOTIFY_INFO) NOTIFY_INFO = cast(List[Any], notification.notify_info)
if self.iterate == False: if self.iterate == False:
if len(NOTIFY_INFO) == 1 and isinstance(NOTIFY_INFO[0], list): if len(NOTIFY_INFO) == 1 and isinstance(NOTIFY_INFO[0], list):
NOTIFY_INFO = NOTIFY_INFO[0] NOTIFY_INFO = NOTIFY_INFO[0]
notification.NOTIFY_INFO = cast(T, self.serializer.klass(**dict(self.serializer._serialize(*NOTIFY_INFO, skip=skip)))) notification.notify_info = cast(T, self.serializer.klass(**dict(self.serializer._serialize(*NOTIFY_INFO, skip=skip))))
else: notification.NOTIFY_INFO = cast(T, [ self.serializer.klass(**dict(self.serializer._serialize(*data, skip=skip))) for data in NOTIFY_INFO ]) else: notification.notify_info = cast(T, [ self.serializer.klass(**dict(self.serializer._serialize(*data, skip=skip))) for data in NOTIFY_INFO ])
return notification return notification

526
bfxapi/rest/BfxRestInterface.py
View File

@@ -1,527 +1,13 @@
import time, hmac, hashlib, json, requests from typing import Optional
from decimal import Decimal from ._RestPublicEndpoints import _RestPublicEndpoints
from datetime import datetime
from http import HTTPStatus
from typing import List, Union, Literal, Optional, Any, cast from ._RestAuthenticatedEndpoints import _RestAuthenticatedEndpoints
from . import serializers
from .types import *
from .enums import Config, Sort, OrderType, FundingOfferType, Error
from .exceptions import ResourceNotFound, RequestParametersError, InvalidAuthenticationCredentials, UnknownGenericError
from .. utils.encoder import JSONEncoder
class BfxRestInterface(object): class BfxRestInterface(object):
def __init__(self, host, API_KEY = None, API_SECRET = None): VERSION = 2
def __init__(self, host: str, API_KEY: Optional[str] = None, API_SECRET: Optional[str] = None):
self.public = _RestPublicEndpoints(host=host) self.public = _RestPublicEndpoints(host=host)
self.auth = _RestAuthenticatedEndpoints(host=host, API_KEY=API_KEY, API_SECRET=API_SECRET) self.auth = _RestAuthenticatedEndpoints(host=host, API_KEY=API_KEY, API_SECRET=API_SECRET)
class _Requests(object):
def __init__(self, host, API_KEY = None, API_SECRET = None):
self.host, self.API_KEY, self.API_SECRET = host, API_KEY, API_SECRET
def __build_authentication_headers(self, endpoint, data):
nonce = str(int(time.time()) * 1000)
path = f"/api/v2/{endpoint}{nonce}"
if data != None: path += data
signature = hmac.new(
self.API_SECRET.encode("utf8"),
path.encode("utf8"),
hashlib.sha384
).hexdigest()
return {
"bfx-nonce": nonce,
"bfx-signature": signature,
"bfx-apikey": self.API_KEY
}
def _GET(self, endpoint, params = None):
response = requests.get(f"{self.host}/{endpoint}", params=params)
if response.status_code == HTTPStatus.NOT_FOUND:
raise ResourceNotFound(f"No resources found at endpoint <{endpoint}>.")
data = response.json()
if len(data) and data[0] == "error":
if data[1] == Error.ERR_PARAMS:
raise RequestParametersError(f"The request was rejected with the following parameter error: <{data[2]}>")
if data[1] == None or data[1] == Error.ERR_UNK or data[1] == Error.ERR_GENERIC:
raise UnknownGenericError(f"The server replied to the request with a generic error with message: <{data[2]}>.")
return data
def _POST(self, endpoint, params = None, data = None):
headers = { "Content-Type": "application/json" }
if isinstance(data, dict):
data = json.dumps({ key: value for key, value in data.items() if value != None}, cls=JSONEncoder)
if self.API_KEY and self.API_SECRET:
headers = { **headers, **self.__build_authentication_headers(endpoint, data) }
response = requests.post(f"{self.host}/{endpoint}", params=params, data=data, headers=headers)
if response.status_code == HTTPStatus.NOT_FOUND:
raise ResourceNotFound(f"No resources found at endpoint <{endpoint}>.")
data = response.json()
if len(data) and data[0] == "error":
if data[1] == Error.ERR_PARAMS:
raise RequestParametersError(f"The request was rejected with the following parameter error: <{data[2]}>")
if data[1] == Error.ERR_AUTH_FAIL:
raise InvalidAuthenticationCredentials("Cannot authenticate with given API-KEY and API-SECRET.")
if data[1] == None or data[1] == Error.ERR_UNK or data[1] == Error.ERR_GENERIC:
raise UnknownGenericError(f"The server replied to the request with a generic error with message: <{data[2]}>.")
return data
class _RestPublicEndpoints(_Requests):
def get_platform_status(self) -> PlatformStatus:
return serializers.PlatformStatus.parse(*self._GET("platform/status"))
def get_tickers(self, symbols: List[str]) -> List[Union[TradingPairTicker, FundingCurrencyTicker]]:
data = self._GET("tickers", params={ "symbols": ",".join(symbols) })
parsers = { "t": serializers.TradingPairTicker.parse, "f": serializers.FundingCurrencyTicker.parse }
return [ cast(Union[TradingPairTicker, FundingCurrencyTicker], parsers[sub_data[0][0]](*sub_data)) for sub_data in data ]
def get_t_tickers(self, pairs: Union[List[str], Literal["ALL"]]) -> List[TradingPairTicker]:
if isinstance(pairs, str) and pairs == "ALL":
return [ cast(TradingPairTicker, sub_data) for sub_data in self.get_tickers([ "ALL" ]) if cast(str, sub_data.SYMBOL).startswith("t") ]
data = self.get_tickers([ "t" + pair for pair in pairs ])
return cast(List[TradingPairTicker], data)
def get_f_tickers(self, currencies: Union[List[str], Literal["ALL"]]) -> List[FundingCurrencyTicker]:
if isinstance(currencies, str) and currencies == "ALL":
return [ cast(FundingCurrencyTicker, sub_data) for sub_data in self.get_tickers([ "ALL" ]) if cast(str, sub_data.SYMBOL).startswith("f") ]
data = self.get_tickers([ "f" + currency for currency in currencies ])
return cast(List[FundingCurrencyTicker], data)
def get_t_ticker(self, pair: str) -> TradingPairTicker:
return serializers.TradingPairTicker.parse(*self._GET(f"ticker/t{pair}"), skip=["SYMBOL"])
def get_f_ticker(self, currency: str) -> FundingCurrencyTicker:
return serializers.FundingCurrencyTicker.parse(*self._GET(f"ticker/f{currency}"), skip=["SYMBOL"])
def get_tickers_history(self, symbols: List[str], start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[TickersHistory]:
params = {
"symbols": ",".join(symbols),
"start": start, "end": end,
"limit": limit
}
data = self._GET("tickers/hist", params=params)
return [ serializers.TickersHistory.parse(*sub_data) for sub_data in data ]
def get_t_trades(self, pair: str, limit: Optional[int] = None, start: Optional[str] = None, end: Optional[str] = None, sort: Optional[Sort] = None) -> List[TradingPairTrade]:
params = { "limit": limit, "start": start, "end": end, "sort": sort }
data = self._GET(f"trades/{'t' + pair}/hist", params=params)
return [ serializers.TradingPairTrade.parse(*sub_data) for sub_data in data ]
def get_f_trades(self, currency: str, limit: Optional[int] = None, start: Optional[str] = None, end: Optional[str] = None, sort: Optional[Sort] = None) -> List[FundingCurrencyTrade]:
params = { "limit": limit, "start": start, "end": end, "sort": sort }
data = self._GET(f"trades/{'f' + currency}/hist", params=params)
return [ serializers.FundingCurrencyTrade.parse(*sub_data) for sub_data in data ]
def get_t_book(self, pair: str, precision: Literal["P0", "P1", "P2", "P3", "P4"], len: Optional[Literal[1, 25, 100]] = None) -> List[TradingPairBook]:
return [ serializers.TradingPairBook.parse(*sub_data) for sub_data in self._GET(f"book/{'t' + pair}/{precision}", params={ "len": len }) ]
def get_f_book(self, currency: str, precision: Literal["P0", "P1", "P2", "P3", "P4"], len: Optional[Literal[1, 25, 100]] = None) -> List[FundingCurrencyBook]:
return [ serializers.FundingCurrencyBook.parse(*sub_data) for sub_data in self._GET(f"book/{'f' + currency}/{precision}", params={ "len": len }) ]
def get_t_raw_book(self, pair: str, len: Optional[Literal[1, 25, 100]] = None) -> List[TradingPairRawBook]:
return [ serializers.TradingPairRawBook.parse(*sub_data) for sub_data in self._GET(f"book/{'t' + pair}/R0", params={ "len": len }) ]
def get_f_raw_book(self, currency: str, len: Optional[Literal[1, 25, 100]] = None) -> List[FundingCurrencyRawBook]:
return [ serializers.FundingCurrencyRawBook.parse(*sub_data) for sub_data in self._GET(f"book/{'f' + currency}/R0", params={ "len": len }) ]
def get_stats_hist(
self,
resource: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> List[Statistic]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"stats1/{resource}/hist", params=params)
return [ serializers.Statistic.parse(*sub_data) for sub_data in data ]
def get_stats_last(
self,
resource: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> Statistic:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"stats1/{resource}/last", params=params)
return serializers.Statistic.parse(*data)
def get_candles_hist(
self,
symbol: str, tf: str = "1m",
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> List[Candle]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"candles/trade:{tf}:{symbol}/hist", params=params)
return [ serializers.Candle.parse(*sub_data) for sub_data in data ]
def get_candles_last(
self,
symbol: str, tf: str = "1m",
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> Candle:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"candles/trade:{tf}:{symbol}/last", params=params)
return serializers.Candle.parse(*data)
def get_derivatives_status(self, keys: Union[List[str], Literal["ALL"]]) -> List[DerivativesStatus]:
if keys == "ALL":
params = { "keys": "ALL" }
else: params = { "keys": ",".join(keys) }
data = self._GET(f"status/deriv", params=params)
return [ serializers.DerivativesStatus.parse(*sub_data) for sub_data in data ]
def get_derivatives_status_history(
self,
type: str, symbol: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> List[DerivativesStatus]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"status/{type}/{symbol}/hist", params=params)
return [ serializers.DerivativesStatus.parse(*sub_data, skip=[ "KEY" ]) for sub_data in data ]
def get_liquidations(self, sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Liquidation]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET("liquidations/hist", params=params)
return [ serializers.Liquidation.parse(*sub_data[0]) for sub_data in data ]
def get_seed_candles(self, symbol: str, tf: str = '1m', sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Candle]:
params = {"sort": sort, "start": start, "end": end, "limit": limit}
data = self._GET(f"candles/trade:{tf}:{symbol}/hist?limit={limit}&start={start}&end={end}&sort={sort}", params=params)
return [ serializers.Candle.parse(*sub_data) for sub_data in data ]
def get_leaderboards_hist(
self,
resource: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> List[Leaderboard]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"rankings/{resource}/hist", params=params)
return [ serializers.Leaderboard.parse(*sub_data) for sub_data in data ]
def get_leaderboards_last(
self,
resource: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> Leaderboard:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"rankings/{resource}/last", params=params)
return serializers.Leaderboard.parse(*data)
def get_funding_stats(self, symbol: str, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[FundingStatistic]:
params = { "start": start, "end": end, "limit": limit }
data = self._GET(f"funding/stats/{symbol}/hist", params=params)
return [ serializers.FundingStatistic.parse(*sub_data) for sub_data in data ]
def conf(self, config: Config) -> Any:
return self._GET(f"conf/{config}")[0]
def get_pulse_profile(self, nickname: str) -> PulseProfile:
return serializers.PulseProfile.parse(*self._GET(f"pulse/profile/{nickname}"))
def get_pulse_history(self, end: Optional[str] = None, limit: Optional[int] = None) -> List[PulseMessage]:
messages = list()
for subdata in self._GET("pulse/hist", params={ "end": end, "limit": limit }):
subdata[18] = subdata[18][0]
message = serializers.PulseMessage.parse(*subdata)
messages.append(message)
return messages
def get_trading_market_average_price(self, symbol: str, amount: Union[Decimal, float, str], price_limit: Optional[Union[Decimal, float, str]] = None) -> TradingMarketAveragePrice:
data = {
"symbol": symbol, "amount": amount, "price_limit": price_limit
}
return serializers.TradingMarketAveragePrice.parse(*self._POST("calc/trade/avg", data=data))
def get_funding_market_average_price(self, symbol: str, amount: Union[Decimal, float, str], period: int, rate_limit: Optional[Union[Decimal, float, str]] = None) -> FundingMarketAveragePrice:
data = {
"symbol": symbol, "amount": amount, "period": period,
"rate_limit": rate_limit
}
return serializers.FundingMarketAveragePrice.parse(*self._POST("calc/trade/avg", data=data))
def get_fx_rate(self, ccy1: str, ccy2: str) -> FxRate:
return serializers.FxRate.parse(*self._POST("calc/fx", data={ "ccy1": ccy1, "ccy2": ccy2 }))
class _RestAuthenticatedEndpoints(_Requests):
def get_wallets(self) -> List[Wallet]:
return [ serializers.Wallet.parse(*sub_data) for sub_data in self._POST("auth/r/wallets") ]
def get_orders(self, symbol: Optional[str] = None, ids: Optional[List[str]] = None) -> List[Order]:
endpoint = "auth/r/orders"
if symbol != None:
endpoint += f"/{symbol}"
return [ serializers.Order.parse(*sub_data) for sub_data in self._POST(endpoint, data={ "id": ids }) ]
def get_positions(self) -> List[Position]:
return [ serializers.Position.parse(*sub_data) for sub_data in self._POST("auth/r/positions") ]
def submit_order(self, type: OrderType, symbol: str, amount: Union[Decimal, float, str],
price: Optional[Union[Decimal, float, str]] = None, lev: Optional[int] = None,
price_trailing: Optional[Union[Decimal, float, str]] = None, price_aux_limit: Optional[Union[Decimal, float, str]] = None, price_oco_stop: Optional[Union[Decimal, float, str]] = None,
gid: Optional[int] = None, cid: Optional[int] = None,
flags: Optional[int] = 0, tif: Optional[Union[datetime, str]] = None, meta: Optional[JSON] = None) -> Notification[Order]:
data = {
"type": type, "symbol": symbol, "amount": amount,
"price": price, "lev": lev,
"price_trailing": price_trailing, "price_aux_limit": price_aux_limit, "price_oco_stop": price_oco_stop,
"gid": gid, "cid": cid,
"flags": flags, "tif": tif, "meta": meta
}
return serializers._Notification[Order](serializer=serializers.Order).parse(*self._POST("auth/w/order/submit", data=data))
def update_order(self, id: int, amount: Optional[Union[Decimal, float, str]] = None, price: Optional[Union[Decimal, float, str]] = None,
cid: Optional[int] = None, cid_date: Optional[str] = None, gid: Optional[int] = None,
flags: Optional[int] = 0, lev: Optional[int] = None, delta: Optional[Union[Decimal, float, str]] = None,
price_aux_limit: Optional[Union[Decimal, float, str]] = None, price_trailing: Optional[Union[Decimal, float, str]] = None, tif: Optional[Union[datetime, str]] = None) -> Notification[Order]:
data = {
"id": id, "amount": amount, "price": price,
"cid": cid, "cid_date": cid_date, "gid": gid,
"flags": flags, "lev": lev, "delta": delta,
"price_aux_limit": price_aux_limit, "price_trailing": price_trailing, "tif": tif
}
return serializers._Notification[Order](serializer=serializers.Order).parse(*self._POST("auth/w/order/update", data=data))
def cancel_order(self, id: Optional[int] = None, cid: Optional[int] = None, cid_date: Optional[str] = None) -> Notification[Order]:
data = {
"id": id,
"cid": cid,
"cid_date": cid_date
}
return serializers._Notification[Order](serializer=serializers.Order).parse(*self._POST("auth/w/order/cancel", data=data))
def cancel_order_multi(self, ids: Optional[List[int]] = None, cids: Optional[List[Tuple[int, str]]] = None, gids: Optional[List[int]] = None, all: bool = False) -> Notification[List[Order]]:
data = {
"ids": ids,
"cids": cids,
"gids": gids,
"all": int(all)
}
return serializers._Notification[List[Order]](serializer=serializers.Order, iterate=True).parse(*self._POST("auth/w/order/cancel/multi", data=data))
def get_orders_history(self, symbol: Optional[str] = None, ids: Optional[List[int]] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Order]:
if symbol == None:
endpoint = "auth/r/orders/hist"
else: endpoint = f"auth/r/orders/{symbol}/hist"
data = {
"id": ids,
"start": start, "end": end,
"limit": limit
}
return [ serializers.Order.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_trades_history(self, symbol: Optional[str] = None, sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Trade]:
if symbol == None:
endpoint = "auth/r/trades/hist"
else: endpoint = f"auth/r/trades/{symbol}/hist"
data = {
"sort": sort,
"start": start, "end": end,
"limit": limit
}
return [ serializers.Trade.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_order_trades(self, symbol: str, id: int) -> List[OrderTrade]:
return [ serializers.OrderTrade.parse(*sub_data) for sub_data in self._POST(f"auth/r/order/{symbol}:{id}/trades") ]
def get_ledgers(self, currency: str, category: Optional[int] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Ledger]:
data = {
"category": category,
"start": start, "end": end,
"limit": limit
}
return [ serializers.Ledger.parse(*sub_data) for sub_data in self._POST(f"auth/r/ledgers/{currency}/hist", data=data) ]
def get_funding_offers(self, symbol: Optional[str] = None) -> List[FundingOffer]:
endpoint = "auth/r/funding/offers"
if symbol != None:
endpoint += f"/{symbol}"
return [ serializers.FundingOffer.parse(*sub_data) for sub_data in self._POST(endpoint) ]
def submit_funding_offer(self, type: FundingOfferType, symbol: str, amount: Union[Decimal, float, str],
rate: Union[Decimal, float, str], period: int,
flags: Optional[int] = 0) -> Notification[FundingOffer]:
data = {
"type": type, "symbol": symbol, "amount": amount,
"rate": rate, "period": period,
"flags": flags
}
return serializers._Notification[FundingOffer](serializer=serializers.FundingOffer).parse(*self._POST("auth/w/funding/offer/submit", data=data))
def cancel_funding_offer(self, id: int) -> Notification[FundingOffer]:
return serializers._Notification[FundingOffer](serializer=serializers.FundingOffer).parse(*self._POST("auth/w/funding/offer/cancel", data={ "id": id }))
def cancel_all_funding_offers(self, currency: str) -> Notification:
return serializers._Notification().parse(*self._POST("auth/w/funding/offer/cancel/all", data={ "currency": currency }))
def get_funding_offers_history(self, symbol: Optional[str] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[FundingOffer]:
if symbol == None:
endpoint = "auth/r/funding/offers/hist"
else: endpoint = f"auth/r/funding/offers/{symbol}/hist"
data = {
"start": start, "end": end,
"limit": limit
}
return [ serializers.FundingOffer.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_funding_credits(self, symbol: Optional[str] = None) -> List[FundingCredit]:
if symbol == None:
endpoint = "auth/r/funding/credits"
else: endpoint = f"auth/r/funding/credits/{symbol}"
return [ serializers.FundingCredit.parse(*sub_data) for sub_data in self._POST(endpoint) ]
def get_funding_credits_history(self, symbol: Optional[str] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[FundingCredit]:
if symbol == None:
endpoint = "auth/r/funding/credits/hist"
else: endpoint = f"auth/r/funding/credits/{symbol}/hist"
data = {
"start": start, "end": end,
"limit": limit
}
return [ serializers.FundingCredit.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def submit_wallet_transfer(self, from_wallet: str, to_wallet: str, currency: str, currency_to: str, amount: Union[Decimal, float, str]) -> Notification[Transfer]:
data = {
"from": from_wallet, "to": to_wallet,
"currency": currency, "currency_to": currency_to,
"amount": amount
}
return serializers._Notification[Transfer](serializer=serializers.Transfer).parse(*self._POST("auth/w/transfer", data=data))
def submit_wallet_withdraw(self, wallet: str, method: str, address: str, amount: Union[Decimal, float, str]) -> Notification[Withdrawal]:
data = {
"wallet": wallet, "method": method,
"address": address, "amount": amount,
}
return serializers._Notification[Withdrawal](serializer=serializers.Withdrawal).parse(*self._POST("auth/w/withdraw", data=data))
def get_deposit_address(self, wallet: str, method: str, renew: bool = False) -> Notification[DepositAddress]:
data = {
"wallet": wallet,
"method": method,
"renew": int(renew)
}
return serializers._Notification[DepositAddress](serializer=serializers.DepositAddress).parse(*self._POST("auth/w/deposit/address", data=data))
def get_deposit_invoice(self, wallet: str, currency: str, amount: Union[Decimal, float, str]) -> Invoice:
data = {
"wallet": wallet, "currency": currency,
"amount": amount
}
return serializers.Invoice.parse(*self._POST("auth/w/deposit/invoice", data=data))
def get_movements(self, currency: Optional[str] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Movement]:
if currency == None:
endpoint = "auth/r/movements/hist"
else: endpoint = f"auth/r/movements/{currency}/hist"
data = {
"start": start, "end": end,
"limit": limit
}
return [ serializers.Movement.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_symbol_margin_info(self, symbol: str) -> SymbolMarginInfo:
response = self._POST(f"auth/r/info/margin/{symbol}")
return serializers.SymbolMarginInfo.parse(*([response[1]] + response[2]))
def get_all_symbols_margin_info(self) -> List[SymbolMarginInfo]:
return [ serializers.SymbolMarginInfo.parse(*([sub_data[1]] + sub_data[2])) for sub_data in self._POST(f"auth/r/info/margin/sym_all") ]
def get_base_margin_info(self) -> BaseMarginInfo:
return serializers.BaseMarginInfo.parse(*(self._POST(f"auth/r/info/margin/base")[1]))
def claim_position(self, id: int, amount: Optional[Union[Decimal, float, str]] = None) -> Notification[Claim]:
return serializers._Notification[Claim](serializer=serializers.Claim).parse(*self._POST("auth/w/position/claim", data={ "id": id, "amount": amount }))
def get_increase_position_info(self, symbol: str, amount: Union[Decimal, float, str]) -> IncreaseInfo:
response = self._POST(f"auth/r/position/increase/info", data={ "symbol": symbol, "amount": amount })
return serializers.IncreaseInfo.parse(*(
response[0] + [response[1][0]] + response[1][1] + [response[1][2]] + response[4] + response[5]
))
def increase_position(self, symbol: str, amount: Union[Decimal, float, str]) -> Notification[Increase]:
return serializers._Notification[Increase](serializer=serializers.Increase).parse(*self._POST("auth/w/position/increase", data={ "symbol": symbol, "amount": amount }))
def get_positions_history(self, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[PositionHistory]:
return [ serializers.PositionHistory.parse(*sub_data) for sub_data in self._POST("auth/r/positions/hist", data={ "start": start, "end": end, "limit": limit }) ]
def get_positions_snapshot(self, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[PositionSnapshot]:
return [ serializers.PositionSnapshot.parse(*sub_data) for sub_data in self._POST("auth/r/positions/snap", data={ "start": start, "end": end, "limit": limit }) ]
def get_positions_audit(self, ids: Optional[List[int]] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[PositionAudit]:
return [ serializers.PositionAudit.parse(*sub_data) for sub_data in self._POST("auth/r/positions/audit", data={ "ids": ids, "start": start, "end": end, "limit": limit }) ]
def set_derivative_position_collateral(self, symbol: str, collateral: Union[Decimal, float, str]) -> DerivativePositionCollateral:
return serializers.DerivativePositionCollateral.parse(*(self._POST("auth/w/deriv/collateral/set", data={ "symbol": symbol, "collateral": collateral })[0]))
def get_derivative_position_collateral_limits(self, symbol: str) -> DerivativePositionCollateralLimits:
return serializers.DerivativePositionCollateralLimits.parse(*self._POST("auth/calc/deriv/collateral/limits", data={ "symbol": symbol }))

75
bfxapi/rest/_Requests.py Normal file
View File

@@ -0,0 +1,75 @@
import time, hmac, hashlib, json, requests
from http import HTTPStatus
from .enums import Error
from .exceptions import ResourceNotFound, RequestParametersError, InvalidAuthenticationCredentials, UnknownGenericError
from .. utils.encoder import JSONEncoder
class _Requests(object):
def __init__(self, host, API_KEY = None, API_SECRET = None):
self.host, self.API_KEY, self.API_SECRET = host, API_KEY, API_SECRET
def __build_authentication_headers(self, endpoint, data):
nonce = str(int(time.time()) * 1000)
path = f"/api/v2/{endpoint}{nonce}"
if data != None: path += data
signature = hmac.new(
self.API_SECRET.encode("utf8"),
path.encode("utf8"),
hashlib.sha384
).hexdigest()
return {
"bfx-nonce": nonce,
"bfx-signature": signature,
"bfx-apikey": self.API_KEY
}
def _GET(self, endpoint, params = None):
response = requests.get(f"{self.host}/{endpoint}", params=params)
if response.status_code == HTTPStatus.NOT_FOUND:
raise ResourceNotFound(f"No resources found at endpoint <{endpoint}>.")
data = response.json()
if len(data) and data[0] == "error":
if data[1] == Error.ERR_PARAMS:
raise RequestParametersError(f"The request was rejected with the following parameter error: <{data[2]}>")
if data[1] == None or data[1] == Error.ERR_UNK or data[1] == Error.ERR_GENERIC:
raise UnknownGenericError(f"The server replied to the request with a generic error with message: <{data[2]}>.")
return data
def _POST(self, endpoint, params = None, data = None, _ignore_authentication_headers = False):
headers = { "Content-Type": "application/json" }
if isinstance(data, dict):
data = json.dumps({ key: value for key, value in data.items() if value != None}, cls=JSONEncoder)
if self.API_KEY and self.API_SECRET and _ignore_authentication_headers == False:
headers = { **headers, **self.__build_authentication_headers(endpoint, data) }
response = requests.post(f"{self.host}/{endpoint}", params=params, data=data, headers=headers)
if response.status_code == HTTPStatus.NOT_FOUND:
raise ResourceNotFound(f"No resources found at endpoint <{endpoint}>.")
data = response.json()
if len(data) and data[0] == "error":
if data[1] == Error.ERR_PARAMS:
raise RequestParametersError(f"The request was rejected with the following parameter error: <{data[2]}>")
if data[1] == Error.ERR_AUTH_FAIL:
raise InvalidAuthenticationCredentials("Cannot authenticate with given API-KEY and API-SECRET.")
if data[1] == None or data[1] == Error.ERR_UNK or data[1] == Error.ERR_GENERIC:
raise UnknownGenericError(f"The server replied to the request with a generic error with message: <{data[2]}>.")
return data

272
bfxapi/rest/_RestAuthenticatedEndpoints.py Normal file
View File

@@ -0,0 +1,272 @@
from typing import List, Union, Literal, Optional, Any, cast
from .types import *
from . import serializers
from .enums import Config, Sort, OrderType, FundingOfferType
from decimal import Decimal
from datetime import datetime
from ._Requests import _Requests
class _RestAuthenticatedEndpoints(_Requests):
def get_wallets(self) -> List[Wallet]:
return [ serializers.Wallet.parse(*sub_data) for sub_data in self._POST("auth/r/wallets") ]
def get_orders(self, symbol: Optional[str] = None, ids: Optional[List[str]] = None) -> List[Order]:
endpoint = "auth/r/orders"
if symbol != None:
endpoint += f"/{symbol}"
return [ serializers.Order.parse(*sub_data) for sub_data in self._POST(endpoint, data={ "id": ids }) ]
def get_positions(self) -> List[Position]:
return [ serializers.Position.parse(*sub_data) for sub_data in self._POST("auth/r/positions") ]
def submit_order(self, type: OrderType, symbol: str, amount: Union[Decimal, float, str],
price: Optional[Union[Decimal, float, str]] = None, lev: Optional[int] = None,
price_trailing: Optional[Union[Decimal, float, str]] = None, price_aux_limit: Optional[Union[Decimal, float, str]] = None, price_oco_stop: Optional[Union[Decimal, float, str]] = None,
gid: Optional[int] = None, cid: Optional[int] = None,
flags: Optional[int] = 0, tif: Optional[Union[datetime, str]] = None, meta: Optional[JSON] = None) -> Notification[Order]:
data = {
"type": type, "symbol": symbol, "amount": amount,
"price": price, "lev": lev,
"price_trailing": price_trailing, "price_aux_limit": price_aux_limit, "price_oco_stop": price_oco_stop,
"gid": gid, "cid": cid,
"flags": flags, "tif": tif, "meta": meta
}
return serializers._Notification[Order](serializer=serializers.Order).parse(*self._POST("auth/w/order/submit", data=data))
def update_order(self, id: int, amount: Optional[Union[Decimal, float, str]] = None, price: Optional[Union[Decimal, float, str]] = None,
cid: Optional[int] = None, cid_date: Optional[str] = None, gid: Optional[int] = None,
flags: Optional[int] = 0, lev: Optional[int] = None, delta: Optional[Union[Decimal, float, str]] = None,
price_aux_limit: Optional[Union[Decimal, float, str]] = None, price_trailing: Optional[Union[Decimal, float, str]] = None, tif: Optional[Union[datetime, str]] = None) -> Notification[Order]:
data = {
"id": id, "amount": amount, "price": price,
"cid": cid, "cid_date": cid_date, "gid": gid,
"flags": flags, "lev": lev, "delta": delta,
"price_aux_limit": price_aux_limit, "price_trailing": price_trailing, "tif": tif
}
return serializers._Notification[Order](serializer=serializers.Order).parse(*self._POST("auth/w/order/update", data=data))
def cancel_order(self, id: Optional[int] = None, cid: Optional[int] = None, cid_date: Optional[str] = None) -> Notification[Order]:
data = {
"id": id,
"cid": cid,
"cid_date": cid_date
}
return serializers._Notification[Order](serializer=serializers.Order).parse(*self._POST("auth/w/order/cancel", data=data))
def cancel_order_multi(self, ids: Optional[List[int]] = None, cids: Optional[List[Tuple[int, str]]] = None, gids: Optional[List[int]] = None, all: bool = False) -> Notification[List[Order]]:
data = {
"ids": ids,
"cids": cids,
"gids": gids,
"all": int(all)
}
return serializers._Notification[List[Order]](serializer=serializers.Order, iterate=True).parse(*self._POST("auth/w/order/cancel/multi", data=data))
def get_orders_history(self, symbol: Optional[str] = None, ids: Optional[List[int]] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Order]:
if symbol == None:
endpoint = "auth/r/orders/hist"
else: endpoint = f"auth/r/orders/{symbol}/hist"
data = {
"id": ids,
"start": start, "end": end,
"limit": limit
}
return [ serializers.Order.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_trades_history(self, symbol: Optional[str] = None, sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Trade]:
if symbol == None:
endpoint = "auth/r/trades/hist"
else: endpoint = f"auth/r/trades/{symbol}/hist"
data = {
"sort": sort,
"start": start, "end": end,
"limit": limit
}
return [ serializers.Trade.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_order_trades(self, symbol: str, id: int) -> List[OrderTrade]:
return [ serializers.OrderTrade.parse(*sub_data) for sub_data in self._POST(f"auth/r/order/{symbol}:{id}/trades") ]
def get_ledgers(self, currency: str, category: Optional[int] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Ledger]:
data = {
"category": category,
"start": start, "end": end,
"limit": limit
}
return [ serializers.Ledger.parse(*sub_data) for sub_data in self._POST(f"auth/r/ledgers/{currency}/hist", data=data) ]
def get_funding_offers(self, symbol: Optional[str] = None) -> List[FundingOffer]:
endpoint = "auth/r/funding/offers"
if symbol != None:
endpoint += f"/{symbol}"
return [ serializers.FundingOffer.parse(*sub_data) for sub_data in self._POST(endpoint) ]
def submit_funding_offer(self, type: FundingOfferType, symbol: str, amount: Union[Decimal, float, str],
rate: Union[Decimal, float, str], period: int,
flags: Optional[int] = 0) -> Notification[FundingOffer]:
data = {
"type": type, "symbol": symbol, "amount": amount,
"rate": rate, "period": period,
"flags": flags
}
return serializers._Notification[FundingOffer](serializer=serializers.FundingOffer).parse(*self._POST("auth/w/funding/offer/submit", data=data))
def cancel_funding_offer(self, id: int) -> Notification[FundingOffer]:
return serializers._Notification[FundingOffer](serializer=serializers.FundingOffer).parse(*self._POST("auth/w/funding/offer/cancel", data={ "id": id }))
def cancel_all_funding_offers(self, currency: str) -> Notification:
return serializers._Notification().parse(*self._POST("auth/w/funding/offer/cancel/all", data={ "currency": currency }))
def get_funding_offers_history(self, symbol: Optional[str] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[FundingOffer]:
if symbol == None:
endpoint = "auth/r/funding/offers/hist"
else: endpoint = f"auth/r/funding/offers/{symbol}/hist"
data = {
"start": start, "end": end,
"limit": limit
}
return [ serializers.FundingOffer.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_funding_loans(self, symbol: Optional[str] = None) -> List[FundingLoan]:
if symbol == None:
endpoint = "auth/r/funding/loans"
else: endpoint = f"auth/r/funding/loans/{symbol}"
return [ serializers.FundingLoan.parse(*sub_data) for sub_data in self._POST(endpoint) ]
def get_funding_loans_history(self, symbol: Optional[str] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[FundingLoan]:
if symbol == None:
endpoint = "auth/r/funding/loans/hist"
else: endpoint = f"auth/r/funding/loans/{symbol}/hist"
data = {
"start": start, "end": end,
"limit": limit
}
return [ serializers.FundingLoan.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_funding_credits(self, symbol: Optional[str] = None) -> List[FundingCredit]:
if symbol == None:
endpoint = "auth/r/funding/credits"
else: endpoint = f"auth/r/funding/credits/{symbol}"
return [ serializers.FundingCredit.parse(*sub_data) for sub_data in self._POST(endpoint) ]
def get_funding_credits_history(self, symbol: Optional[str] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[FundingCredit]:
if symbol == None:
endpoint = "auth/r/funding/credits/hist"
else: endpoint = f"auth/r/funding/credits/{symbol}/hist"
data = {
"start": start, "end": end,
"limit": limit
}
return [ serializers.FundingCredit.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def submit_wallet_transfer(self, from_wallet: str, to_wallet: str, currency: str, currency_to: str, amount: Union[Decimal, float, str]) -> Notification[Transfer]:
data = {
"from": from_wallet, "to": to_wallet,
"currency": currency, "currency_to": currency_to,
"amount": amount
}
return serializers._Notification[Transfer](serializer=serializers.Transfer).parse(*self._POST("auth/w/transfer", data=data))
def submit_wallet_withdraw(self, wallet: str, method: str, address: str, amount: Union[Decimal, float, str]) -> Notification[Withdrawal]:
data = {
"wallet": wallet, "method": method,
"address": address, "amount": amount,
}
return serializers._Notification[Withdrawal](serializer=serializers.Withdrawal).parse(*self._POST("auth/w/withdraw", data=data))
def get_deposit_address(self, wallet: str, method: str, renew: bool = False) -> Notification[DepositAddress]:
data = {
"wallet": wallet,
"method": method,
"renew": int(renew)
}
return serializers._Notification[DepositAddress](serializer=serializers.DepositAddress).parse(*self._POST("auth/w/deposit/address", data=data))
def get_deposit_invoice(self, wallet: str, currency: str, amount: Union[Decimal, float, str]) -> Invoice:
data = {
"wallet": wallet, "currency": currency,
"amount": amount
}
return serializers.Invoice.parse(*self._POST("auth/w/deposit/invoice", data=data))
def get_movements(self, currency: Optional[str] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Movement]:
if currency == None:
endpoint = "auth/r/movements/hist"
else: endpoint = f"auth/r/movements/{currency}/hist"
data = {
"start": start, "end": end,
"limit": limit
}
return [ serializers.Movement.parse(*sub_data) for sub_data in self._POST(endpoint, data=data) ]
def get_symbol_margin_info(self, symbol: str) -> SymbolMarginInfo:
response = self._POST(f"auth/r/info/margin/{symbol}")
return serializers.SymbolMarginInfo.parse(*([response[1]] + response[2]))
def get_all_symbols_margin_info(self) -> List[SymbolMarginInfo]:
return [ serializers.SymbolMarginInfo.parse(*([sub_data[1]] + sub_data[2])) for sub_data in self._POST(f"auth/r/info/margin/sym_all") ]
def get_base_margin_info(self) -> BaseMarginInfo:
return serializers.BaseMarginInfo.parse(*(self._POST(f"auth/r/info/margin/base")[1]))
def claim_position(self, id: int, amount: Optional[Union[Decimal, float, str]] = None) -> Notification[Claim]:
return serializers._Notification[Claim](serializer=serializers.Claim).parse(*self._POST("auth/w/position/claim", data={ "id": id, "amount": amount }))
def get_increase_position_info(self, symbol: str, amount: Union[Decimal, float, str]) -> IncreaseInfo:
response = self._POST(f"auth/r/position/increase/info", data={ "symbol": symbol, "amount": amount })
return serializers.IncreaseInfo.parse(*(
response[0] + [response[1][0]] + response[1][1] + [response[1][2]] + response[4] + response[5]
))
def increase_position(self, symbol: str, amount: Union[Decimal, float, str]) -> Notification[Increase]:
return serializers._Notification[Increase](serializer=serializers.Increase).parse(*self._POST("auth/w/position/increase", data={ "symbol": symbol, "amount": amount }))
def get_positions_history(self, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[PositionHistory]:
return [ serializers.PositionHistory.parse(*sub_data) for sub_data in self._POST("auth/r/positions/hist", data={ "start": start, "end": end, "limit": limit }) ]
def get_positions_snapshot(self, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[PositionSnapshot]:
return [ serializers.PositionSnapshot.parse(*sub_data) for sub_data in self._POST("auth/r/positions/snap", data={ "start": start, "end": end, "limit": limit }) ]
def get_positions_audit(self, ids: Optional[List[int]] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[PositionAudit]:
return [ serializers.PositionAudit.parse(*sub_data) for sub_data in self._POST("auth/r/positions/audit", data={ "ids": ids, "start": start, "end": end, "limit": limit }) ]
def set_derivative_position_collateral(self, symbol: str, collateral: Union[Decimal, float, str]) -> DerivativePositionCollateral:
return serializers.DerivativePositionCollateral.parse(*(self._POST("auth/w/deriv/collateral/set", data={ "symbol": symbol, "collateral": collateral })[0]))
def get_derivative_position_collateral_limits(self, symbol: str) -> DerivativePositionCollateralLimits:
return serializers.DerivativePositionCollateralLimits.parse(*self._POST("auth/calc/deriv/collateral/limits", data={ "symbol": symbol }))

188
bfxapi/rest/_RestPublicEndpoints.py Normal file
View File

@@ -0,0 +1,188 @@
from typing import List, Union, Literal, Optional, Any, cast
from .types import *
from . import serializers
from .enums import Config, Sort
from decimal import Decimal
from ._Requests import _Requests
class _RestPublicEndpoints(_Requests):
def conf(self, config: Config) -> Any:
return self._GET(f"conf/{config}")[0]
def get_platform_status(self) -> PlatformStatus:
return serializers.PlatformStatus.parse(*self._GET("platform/status"))
def get_tickers(self, symbols: List[str]) -> List[Union[TradingPairTicker, FundingCurrencyTicker]]:
data = self._GET("tickers", params={ "symbols": ",".join(symbols) })
parsers = { "t": serializers.TradingPairTicker.parse, "f": serializers.FundingCurrencyTicker.parse }
return [ cast(Union[TradingPairTicker, FundingCurrencyTicker], parsers[sub_data[0][0]](*sub_data)) for sub_data in data ]
def get_t_tickers(self, pairs: Union[List[str], Literal["ALL"]]) -> List[TradingPairTicker]:
if isinstance(pairs, str) and pairs == "ALL":
return [ cast(TradingPairTicker, sub_data) for sub_data in self.get_tickers([ "ALL" ]) if cast(str, sub_data.symbol).startswith("t") ]
data = self.get_tickers([ "t" + pair for pair in pairs ])
return cast(List[TradingPairTicker], data)
def get_f_tickers(self, currencies: Union[List[str], Literal["ALL"]]) -> List[FundingCurrencyTicker]:
if isinstance(currencies, str) and currencies == "ALL":
return [ cast(FundingCurrencyTicker, sub_data) for sub_data in self.get_tickers([ "ALL" ]) if cast(str, sub_data.symbol).startswith("f") ]
data = self.get_tickers([ "f" + currency for currency in currencies ])
return cast(List[FundingCurrencyTicker], data)
def get_t_ticker(self, pair: str) -> TradingPairTicker:
return serializers.TradingPairTicker.parse(*self._GET(f"ticker/t{pair}"), skip=["SYMBOL"])
def get_f_ticker(self, currency: str) -> FundingCurrencyTicker:
return serializers.FundingCurrencyTicker.parse(*self._GET(f"ticker/f{currency}"), skip=["SYMBOL"])
def get_tickers_history(self, symbols: List[str], start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[TickersHistory]:
return [ serializers.TickersHistory.parse(*sub_data) for sub_data in self._GET("tickers/hist", params={
"symbols": ",".join(symbols),
"start": start, "end": end,
"limit": limit
}) ]
def get_t_trades(self, pair: str, limit: Optional[int] = None, start: Optional[str] = None, end: Optional[str] = None, sort: Optional[Sort] = None) -> List[TradingPairTrade]:
params = { "limit": limit, "start": start, "end": end, "sort": sort }
data = self._GET(f"trades/{'t' + pair}/hist", params=params)
return [ serializers.TradingPairTrade.parse(*sub_data) for sub_data in data ]
def get_f_trades(self, currency: str, limit: Optional[int] = None, start: Optional[str] = None, end: Optional[str] = None, sort: Optional[Sort] = None) -> List[FundingCurrencyTrade]:
params = { "limit": limit, "start": start, "end": end, "sort": sort }
data = self._GET(f"trades/{'f' + currency}/hist", params=params)
return [ serializers.FundingCurrencyTrade.parse(*sub_data) for sub_data in data ]
def get_t_book(self, pair: str, precision: Literal["P0", "P1", "P2", "P3", "P4"], len: Optional[Literal[1, 25, 100]] = None) -> List[TradingPairBook]:
return [ serializers.TradingPairBook.parse(*sub_data) for sub_data in self._GET(f"book/{'t' + pair}/{precision}", params={ "len": len }) ]
def get_f_book(self, currency: str, precision: Literal["P0", "P1", "P2", "P3", "P4"], len: Optional[Literal[1, 25, 100]] = None) -> List[FundingCurrencyBook]:
return [ serializers.FundingCurrencyBook.parse(*sub_data) for sub_data in self._GET(f"book/{'f' + currency}/{precision}", params={ "len": len }) ]
def get_t_raw_book(self, pair: str, len: Optional[Literal[1, 25, 100]] = None) -> List[TradingPairRawBook]:
return [ serializers.TradingPairRawBook.parse(*sub_data) for sub_data in self._GET(f"book/{'t' + pair}/R0", params={ "len": len }) ]
def get_f_raw_book(self, currency: str, len: Optional[Literal[1, 25, 100]] = None) -> List[FundingCurrencyRawBook]:
return [ serializers.FundingCurrencyRawBook.parse(*sub_data) for sub_data in self._GET(f"book/{'f' + currency}/R0", params={ "len": len }) ]
def get_stats_hist(
self,
resource: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> List[Statistic]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"stats1/{resource}/hist", params=params)
return [ serializers.Statistic.parse(*sub_data) for sub_data in data ]
def get_stats_last(
self,
resource: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> Statistic:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"stats1/{resource}/last", params=params)
return serializers.Statistic.parse(*data)
def get_candles_hist(
self,
symbol: str, tf: str = "1m",
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> List[Candle]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"candles/trade:{tf}:{symbol}/hist", params=params)
return [ serializers.Candle.parse(*sub_data) for sub_data in data ]
def get_candles_last(
self,
symbol: str, tf: str = "1m",
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> Candle:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"candles/trade:{tf}:{symbol}/last", params=params)
return serializers.Candle.parse(*data)
def get_derivatives_status(self, keys: Union[List[str], Literal["ALL"]]) -> List[DerivativesStatus]:
if keys == "ALL":
params = { "keys": "ALL" }
else: params = { "keys": ",".join(keys) }
data = self._GET(f"status/deriv", params=params)
return [ serializers.DerivativesStatus.parse(*sub_data) for sub_data in data ]
def get_derivatives_status_history(
self,
type: str, symbol: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> List[DerivativesStatus]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"status/{type}/{symbol}/hist", params=params)
return [ serializers.DerivativesStatus.parse(*sub_data, skip=[ "KEY" ]) for sub_data in data ]
def get_liquidations(self, sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Liquidation]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET("liquidations/hist", params=params)
return [ serializers.Liquidation.parse(*sub_data[0]) for sub_data in data ]
def get_seed_candles(self, symbol: str, tf: str = '1m', sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[Candle]:
params = {"sort": sort, "start": start, "end": end, "limit": limit}
data = self._GET(f"candles/trade:{tf}:{symbol}/hist?limit={limit}&start={start}&end={end}&sort={sort}", params=params)
return [ serializers.Candle.parse(*sub_data) for sub_data in data ]
def get_leaderboards_hist(
self,
resource: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> List[Leaderboard]:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"rankings/{resource}/hist", params=params)
return [ serializers.Leaderboard.parse(*sub_data) for sub_data in data ]
def get_leaderboards_last(
self,
resource: str,
sort: Optional[Sort] = None, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None
) -> Leaderboard:
params = { "sort": sort, "start": start, "end": end, "limit": limit }
data = self._GET(f"rankings/{resource}/last", params=params)
return serializers.Leaderboard.parse(*data)
def get_funding_stats(self, symbol: str, start: Optional[str] = None, end: Optional[str] = None, limit: Optional[int] = None) -> List[FundingStatistic]:
params = { "start": start, "end": end, "limit": limit }
data = self._GET(f"funding/stats/{symbol}/hist", params=params)
return [ serializers.FundingStatistic.parse(*sub_data) for sub_data in data ]
def get_pulse_profile(self, nickname: str) -> PulseProfile:
return serializers.PulseProfile.parse(*self._GET(f"pulse/profile/{nickname}"))
def get_pulse_history(self, end: Optional[str] = None, limit: Optional[int] = None) -> List[PulseMessage]:
messages = list()
for subdata in self._GET("pulse/hist", params={ "end": end, "limit": limit }):
subdata[18] = subdata[18][0]
message = serializers.PulseMessage.parse(*subdata)
messages.append(message)
return messages
def get_trading_market_average_price(self, symbol: str, amount: Union[Decimal, float, str], price_limit: Optional[Union[Decimal, float, str]] = None) -> TradingMarketAveragePrice:
return serializers.TradingMarketAveragePrice.parse(*self._POST("calc/trade/avg", data={
"symbol": symbol, "amount": amount, "price_limit": price_limit
}))
def get_funding_market_average_price(self, symbol: str, amount: Union[Decimal, float, str], period: int, rate_limit: Optional[Union[Decimal, float, str]] = None) -> FundingMarketAveragePrice:
return serializers.FundingMarketAveragePrice.parse(*self._POST("calc/trade/avg", data={
"symbol": symbol, "amount": amount, "period": period, "rate_limit": rate_limit
}))
def get_fx_rate(self, ccy1: str, ccy2: str) -> FxRate:
return serializers.FxRate.parse(*self._POST("calc/fx", data={ "ccy1": ccy1, "ccy2": ccy2 }))

686
bfxapi/rest/serializers.py
View File

@@ -7,48 +7,48 @@ from .. notification import _Notification
#region Serializers definition for Rest Public Endpoints #region Serializers definition for Rest Public Endpoints
PlatformStatus = generate_labeler_serializer("PlatformStatus", klass=types.PlatformStatus, labels=[ PlatformStatus = generate_labeler_serializer("PlatformStatus", klass=types.PlatformStatus, labels=[
"STATUS" "status"
]) ])
TradingPairTicker = generate_labeler_serializer("TradingPairTicker", klass=types.TradingPairTicker, labels=[ TradingPairTicker = generate_labeler_serializer("TradingPairTicker", klass=types.TradingPairTicker, labels=[
"SYMBOL", "symbol",
"BID", "bid",
"BID_SIZE", "bid_size",
"ASK", "ask",
"ASK_SIZE", "ask_size",
"DAILY_CHANGE", "daily_change",
"DAILY_CHANGE_RELATIVE", "daily_change_relative",
"LAST_PRICE", "last_price",
"VOLUME", "volume",
"HIGH", "high",
"LOW" "low"
]) ])
FundingCurrencyTicker = generate_labeler_serializer("FundingCurrencyTicker", klass=types.FundingCurrencyTicker, labels=[ FundingCurrencyTicker = generate_labeler_serializer("FundingCurrencyTicker", klass=types.FundingCurrencyTicker, labels=[
"SYMBOL", "symbol",
"FRR", "frr",
"BID", "bid",
"BID_PERIOD", "bid_period",
"BID_SIZE", "bid_size",
"ASK", "ask",
"ASK_PERIOD", "ask_period",
"ASK_SIZE", "ask_size",
"DAILY_CHANGE", "daily_change",
"DAILY_CHANGE_RELATIVE", "daily_change_relative",
"LAST_PRICE", "last_price",
"VOLUME", "volume",
"HIGH", "high",
"LOW", "low",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"FRR_AMOUNT_AVAILABLE" "frr_amount_available"
]) ])
TickersHistory = generate_labeler_serializer("TickersHistory", klass=types.TickersHistory, labels=[ TickersHistory = generate_labeler_serializer("TickersHistory", klass=types.TickersHistory, labels=[
"SYMBOL", "symbol",
"BID", "bid",
"_PLACEHOLDER", "_PLACEHOLDER",
"ASK", "ask",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
@@ -57,191 +57,191 @@ TickersHistory = generate_labeler_serializer("TickersHistory", klass=types.Ticke
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"MTS" "mts"
]) ])
TradingPairTrade = generate_labeler_serializer("TradingPairTrade", klass=types.TradingPairTrade, labels=[ TradingPairTrade = generate_labeler_serializer("TradingPairTrade", klass=types.TradingPairTrade, labels=[
"ID", "id",
"MTS", "mts",
"AMOUNT", "amount",
"PRICE" "price"
]) ])
FundingCurrencyTrade = generate_labeler_serializer("FundingCurrencyTrade", klass=types.FundingCurrencyTrade, labels=[ FundingCurrencyTrade = generate_labeler_serializer("FundingCurrencyTrade", klass=types.FundingCurrencyTrade, labels=[
"ID", "id",
"MTS", "mts",
"AMOUNT", "amount",
"RATE", "rate",
"PERIOD" "period"
]) ])
TradingPairBook = generate_labeler_serializer("TradingPairBook", klass=types.TradingPairBook, labels=[ TradingPairBook = generate_labeler_serializer("TradingPairBook", klass=types.TradingPairBook, labels=[
"PRICE", "price",
"COUNT", "count",
"AMOUNT" "amount"
]) ])
FundingCurrencyBook = generate_labeler_serializer("FundingCurrencyBook", klass=types.FundingCurrencyBook, labels=[ FundingCurrencyBook = generate_labeler_serializer("FundingCurrencyBook", klass=types.FundingCurrencyBook, labels=[
"RATE", "rate",
"PERIOD", "period",
"COUNT", "count",
"AMOUNT" "amount"
]) ])
TradingPairRawBook = generate_labeler_serializer("TradingPairRawBook", klass=types.TradingPairRawBook, labels=[ TradingPairRawBook = generate_labeler_serializer("TradingPairRawBook", klass=types.TradingPairRawBook, labels=[
"ORDER_ID", "order_id",
"PRICE", "price",
"AMOUNT" "amount"
]) ])
FundingCurrencyRawBook = generate_labeler_serializer("FundingCurrencyRawBook", klass=types.FundingCurrencyRawBook, labels=[ FundingCurrencyRawBook = generate_labeler_serializer("FundingCurrencyRawBook", klass=types.FundingCurrencyRawBook, labels=[
"OFFER_ID", "offer_id",
"PERIOD", "period",
"RATE", "rate",
"AMOUNT" "amount"
]) ])
Statistic = generate_labeler_serializer("Statistic", klass=types.Statistic, labels=[ Statistic = generate_labeler_serializer("Statistic", klass=types.Statistic, labels=[
"MTS", "mts",
"VALUE" "value"
]) ])
Candle = generate_labeler_serializer("Candle", klass=types.Candle, labels=[ Candle = generate_labeler_serializer("Candle", klass=types.Candle, labels=[
"MTS", "mts",
"OPEN", "open",
"CLOSE", "close",
"HIGH", "high",
"LOW", "low",
"VOLUME" "volume"
]) ])
DerivativesStatus = generate_labeler_serializer("DerivativesStatus", klass=types.DerivativesStatus, labels=[ DerivativesStatus = generate_labeler_serializer("DerivativesStatus", klass=types.DerivativesStatus, labels=[
"KEY", "key",
"MTS", "mts",
"_PLACEHOLDER", "_PLACEHOLDER",
"DERIV_PRICE", "deriv_price",
"SPOT_PRICE", "spot_price",
"_PLACEHOLDER", "_PLACEHOLDER",
"INSURANCE_FUND_BALANCE", "insurance_fund_balance",
"_PLACEHOLDER", "_PLACEHOLDER",
"NEXT_FUNDING_EVT_TIMESTAMP_MS", "next_funding_evt_timestamp_ms",
"NEXT_FUNDING_ACCRUED", "next_funding_accrued",
"NEXT_FUNDING_STEP", "next_funding_step",
"_PLACEHOLDER", "_PLACEHOLDER",
"CURRENT_FUNDING", "current_funding",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"MARK_PRICE", "mark_price",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"OPEN_INTEREST", "open_interest",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"CLAMP_MIN", "clamp_min",
"CLAMP_MAX" "clamp_max"
]) ])
Liquidation = generate_labeler_serializer("Liquidation", klass=types.Liquidation, labels=[ Liquidation = generate_labeler_serializer("Liquidation", klass=types.Liquidation, labels=[
"_PLACEHOLDER", "_PLACEHOLDER",
"POS_ID", "pos_id",
"MTS", "mts",
"_PLACEHOLDER", "_PLACEHOLDER",
"SYMBOL", "symbol",
"AMOUNT", "amount",
"BASE_PRICE", "base_price",
"_PLACEHOLDER", "_PLACEHOLDER",
"IS_MATCH", "is_match",
"IS_MARKET_SOLD", "is_market_sold",
"_PLACEHOLDER", "_PLACEHOLDER",
"PRICE_ACQUIRED" "price_acquired"
]) ])
Leaderboard = generate_labeler_serializer("Leaderboard", klass=types.Leaderboard, labels=[ Leaderboard = generate_labeler_serializer("Leaderboard", klass=types.Leaderboard, labels=[
"MTS", "mts",
"_PLACEHOLDER", "_PLACEHOLDER",
"USERNAME", "username",
"RANKING", "ranking",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"VALUE", "value",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"TWITTER_HANDLE" "twitter_handle"
]) ])
FundingStatistic = generate_labeler_serializer("FundingStatistic", klass=types.FundingStatistic, labels=[ FundingStatistic = generate_labeler_serializer("FundingStatistic", klass=types.FundingStatistic, labels=[
"TIMESTAMP", "timestamp",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"FRR", "frr",
"AVG_PERIOD", "avg_period",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"FUNDING_AMOUNT", "funding_amount",
"FUNDING_AMOUNT_USED", "funding_amount_used",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"FUNDING_BELOW_THRESHOLD" "funding_below_threshold"
]) ])
PulseProfile = generate_labeler_serializer("PulseProfile", klass=types.PulseProfile, labels=[ PulseProfile = generate_labeler_serializer("PulseProfile", klass=types.PulseProfile, labels=[
"PUID", "puid",
"MTS", "mts",
"_PLACEHOLDER", "_PLACEHOLDER",
"NICKNAME", "nickname",
"_PLACEHOLDER", "_PLACEHOLDER",
"PICTURE", "picture",
"TEXT", "text",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"TWITTER_HANDLE", "twitter_handle",
"_PLACEHOLDER", "_PLACEHOLDER",
"FOLLOWERS", "followers",
"FOLLOWING", "following",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"TIPPING_STATUS" "tipping_status"
]) ])
PulseMessage = generate_recursive_serializer("PulseMessage", klass=types.PulseMessage, serializers={ "PROFILE": PulseProfile }, labels=[ PulseMessage = generate_recursive_serializer("PulseMessage", klass=types.PulseMessage, serializers={ "profile": PulseProfile }, labels=[
"PID", "pid",
"MTS", "mts",
"_PLACEHOLDER", "_PLACEHOLDER",
"PUID", "puid",
"_PLACEHOLDER", "_PLACEHOLDER",
"TITLE", "title",
"CONTENT", "content",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"IS_PIN", "is_pin",
"IS_PUBLIC", "is_public",
"COMMENTS_DISABLED", "comments_disabled",
"TAGS", "tags",
"ATTACHMENTS", "attachments",
"META", "meta",
"LIKES", "likes",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"PROFILE", "profile",
"COMMENTS", "comments",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER" "_PLACEHOLDER"
]) ])
TradingMarketAveragePrice = generate_labeler_serializer("TradingMarketAveragePrice", klass=types.TradingMarketAveragePrice, labels=[ TradingMarketAveragePrice = generate_labeler_serializer("TradingMarketAveragePrice", klass=types.TradingMarketAveragePrice, labels=[
"PRICE_AVG", "price_avg",
"AMOUNT" "amount"
]) ])
FundingMarketAveragePrice = generate_labeler_serializer("FundingMarketAveragePrice", klass=types.FundingMarketAveragePrice, labels=[ FundingMarketAveragePrice = generate_labeler_serializer("FundingMarketAveragePrice", klass=types.FundingMarketAveragePrice, labels=[
"RATE_AVG", "rate_avg",
"AMOUNT" "amount"
]) ])
FxRate = generate_labeler_serializer("FxRate", klass=types.FxRate, labels=[ FxRate = generate_labeler_serializer("FxRate", klass=types.FxRate, labels=[
"CURRENT_RATE" "current_rate"
]) ])
#endregion #endregion
@@ -249,358 +249,382 @@ FxRate = generate_labeler_serializer("FxRate", klass=types.FxRate, labels=[
#region Serializers definition for Rest Authenticated Endpoints #region Serializers definition for Rest Authenticated Endpoints
Wallet = generate_labeler_serializer("Wallet", klass=types.Wallet, labels=[ Wallet = generate_labeler_serializer("Wallet", klass=types.Wallet, labels=[
"WALLET_TYPE", "wallet_type",
"CURRENCY", "currency",
"BALANCE", "balance",
"UNSETTLED_INTEREST", "unsettled_interest",
"AVAILABLE_BALANCE", "available_balance",
"LAST_CHANGE", "last_change",
"TRADE_DETAILS" "trade_details"
]) ])
Order = generate_labeler_serializer("Order", klass=types.Order, labels=[ Order = generate_labeler_serializer("Order", klass=types.Order, labels=[
"ID", "id",
"GID", "gid",
"CID", "cid",
"SYMBOL", "symbol",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"AMOUNT", "amount",
"AMOUNT_ORIG", "amount_orig",
"ORDER_TYPE", "order_type",
"TYPE_PREV", "type_prev",
"MTS_TIF", "mts_tif",
"_PLACEHOLDER", "_PLACEHOLDER",
"FLAGS", "flags",
"ORDER_STATUS", "order_status",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"PRICE", "price",
"PRICE_AVG", "price_avg",
"PRICE_TRAILING", "price_trailing",
"PRICE_AUX_LIMIT", "price_aux_limit",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"NOTIFY", "notify",
"HIDDEN", "hidden",
"PLACED_ID", "placed_id",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"ROUTING", "routing",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"META" "meta"
]) ])
Position = generate_labeler_serializer("Position", klass=types.Position, labels=[ Position = generate_labeler_serializer("Position", klass=types.Position, labels=[
"SYMBOL", "symbol",
"STATUS", "status",
"AMOUNT", "amount",
"BASE_PRICE", "base_price",
"MARGIN_FUNDING", "margin_funding",
"MARGIN_FUNDING_TYPE", "margin_funding_type",
"PL", "pl",
"PL_PERC", "pl_perc",
"PRICE_LIQ", "price_liq",
"LEVERAGE", "leverage",
"_PLACEHOLDER", "_PLACEHOLDER",
"POSITION_ID", "position_id",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"_PLACEHOLDER", "_PLACEHOLDER",
"TYPE", "type",
"_PLACEHOLDER", "_PLACEHOLDER",
"COLLATERAL", "collateral",
"COLLATERAL_MIN", "collateral_min",
"META" "meta"
]) ])
FundingOffer = generate_labeler_serializer("FundingOffer", klass=types.FundingOffer, labels=[ FundingOffer = generate_labeler_serializer("FundingOffer", klass=types.FundingOffer, labels=[
"ID", "id",
"SYMBOL", "symbol",
"MTS_CREATED", "mts_created",
"MTS_UPDATED", "mts_updated",
"AMOUNT", "amount",
"AMOUNT_ORIG", "amount_orig",
"OFFER_TYPE", "offer_type",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"FLAGS", "flags",
"OFFER_STATUS", "offer_status",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"RATE", "rate",
"PERIOD", "period",
"NOTIFY", "notify",
"HIDDEN", "hidden",
"_PLACEHOLDER", "_PLACEHOLDER",
"RENEW", "renew",
"_PLACEHOLDER" "_PLACEHOLDER"
]) ])
Trade = generate_labeler_serializer("Trade", klass=types.Trade, labels=[ Trade = generate_labeler_serializer("Trade", klass=types.Trade, labels=[
"ID", "id",
"PAIR", "pair",
"MTS_CREATE", "mts_create",
"ORDER_ID", "order_id",
"EXEC_AMOUNT", "exec_amount",
"EXEC_PRICE", "exec_price",
"ORDER_TYPE", "order_type",
"ORDER_PRICE", "order_price",
"MAKER", "maker",
"FEE", "fee",
"FEE_CURRENCY", "fee_currency",
"CID" "cid"
]) ])
OrderTrade = generate_labeler_serializer("OrderTrade", klass=types.OrderTrade, labels=[ OrderTrade = generate_labeler_serializer("OrderTrade", klass=types.OrderTrade, labels=[
"ID", "id",
"PAIR", "pair",
"MTS_CREATE", "mts_create",
"ORDER_ID", "order_id",
"EXEC_AMOUNT", "exec_amount",
"EXEC_PRICE", "exec_price",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"MAKER", "maker",
"FEE", "fee",
"FEE_CURRENCY", "fee_currency",
"CID" "cid"
]) ])
Ledger = generate_labeler_serializer("Ledger", klass=types.Ledger, labels=[ Ledger = generate_labeler_serializer("Ledger", klass=types.Ledger, labels=[
"ID", "id",
"CURRENCY", "currency",
"_PLACEHOLDER", "_PLACEHOLDER",
"MTS", "mts",
"_PLACEHOLDER", "_PLACEHOLDER",
"AMOUNT", "amount",
"BALANCE", "balance",
"_PLACEHOLDER", "_PLACEHOLDER",
"DESCRIPTION" "description"
])
FundingLoan = generate_labeler_serializer("FundingLoan", klass=types.FundingLoan, labels=[
"id",
"symbol",
"side",
"mts_create",
"mts_update",
"amount",
"flags",
"status",
"_PLACEHOLDER",
"_PLACEHOLDER",
"_PLACEHOLDER",
"rate",
"period",
"mts_opening",
"mts_last_payout",
"notify",
"hidden",
"_PLACEHOLDER",
"renew",
"rate_real",
"no_close"
]) ])
FundingCredit = generate_labeler_serializer("FundingCredit", klass=types.FundingCredit, labels=[ FundingCredit = generate_labeler_serializer("FundingCredit", klass=types.FundingCredit, labels=[
"ID", "id",
"SYMBOL", "symbol",
"SIDE", "side",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"AMOUNT", "amount",
"FLAGS", "flags",
"STATUS", "status",
"RATE_TYPE", "rate_type",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"RATE", "rate",
"PERIOD", "period",
"MTS_OPENING", "mts_opening",
"MTS_LAST_PAYOUT", "mts_last_payout",
"NOTIFY", "notify",
"HIDDEN", "hidden",
"_PLACEHOLDER", "_PLACEHOLDER",
"RENEW", "renew",
"_PLACEHOLDER", "_PLACEHOLDER",
"NO_CLOSE", "no_close",
"POSITION_PAIR" "position_pair"
]) ])
Transfer = generate_labeler_serializer("Transfer", klass=types.Transfer, labels=[ Transfer = generate_labeler_serializer("Transfer", klass=types.Transfer, labels=[
"MTS", "mts",
"WALLET_FROM", "wallet_from",
"WALLET_TO", "wallet_to",
"_PLACEHOLDER", "_PLACEHOLDER",
"CURRENCY", "currency",
"CURRENCY_TO", "currency_to",
"_PLACEHOLDER", "_PLACEHOLDER",
"AMOUNT" "amount"
]) ])
Withdrawal = generate_labeler_serializer("Withdrawal", klass=types.Withdrawal, labels=[ Withdrawal = generate_labeler_serializer("Withdrawal", klass=types.Withdrawal, labels=[
"WITHDRAWAL_ID", "withdrawal_id",
"_PLACEHOLDER", "_PLACEHOLDER",
"METHOD", "method",
"PAYMENT_ID", "payment_id",
"WALLET", "wallet",
"AMOUNT", "amount",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"WITHDRAWAL_FEE" "withdrawal_fee"
]) ])
DepositAddress = generate_labeler_serializer("DepositAddress", klass=types.DepositAddress, labels=[ DepositAddress = generate_labeler_serializer("DepositAddress", klass=types.DepositAddress, labels=[
"_PLACEHOLDER", "_PLACEHOLDER",
"METHOD", "method",
"CURRENCY_CODE", "currency_code",
"_PLACEHOLDER", "_PLACEHOLDER",
"ADDRESS", "address",
"POOL_ADDRESS" "pool_address"
]) ])
Invoice = generate_labeler_serializer("Invoice", klass=types.Invoice, labels=[ Invoice = generate_labeler_serializer("Invoice", klass=types.Invoice, labels=[
"INVOICE_HASH", "invoice_hash",
"INVOICE", "invoice",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"AMOUNT" "amount"
]) ])
Movement = generate_labeler_serializer("Movement", klass=types.Movement, labels=[ Movement = generate_labeler_serializer("Movement", klass=types.Movement, labels=[
"ID", "id",
"CURRENCY", "currency",
"CURRENCY_NAME", "currency_name",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"MTS_STARTED", "mts_started",
"MTS_UPDATED", "mts_updated",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"STATUS", "status",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"AMOUNT", "amount",
"FEES", "fees",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"DESTINATION_ADDRESS", "destination_address",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"TRANSACTION_ID", "transaction_id",
"WITHDRAW_TRANSACTION_NOTE" "withdraw_transaction_note"
]) ])
SymbolMarginInfo = generate_labeler_serializer("SymbolMarginInfo", klass=types.SymbolMarginInfo, labels=[ SymbolMarginInfo = generate_labeler_serializer("SymbolMarginInfo", klass=types.SymbolMarginInfo, labels=[
"SYMBOL", "symbol",
"TRADABLE_BALANCE", "tradable_balance",
"GROSS_BALANCE", "gross_balance",
"BUY", "buy",
"SELL" "sell"
]) ])
BaseMarginInfo = generate_labeler_serializer("BaseMarginInfo", klass=types.BaseMarginInfo, labels=[ BaseMarginInfo = generate_labeler_serializer("BaseMarginInfo", klass=types.BaseMarginInfo, labels=[
"USER_PL", "user_pl",
"USER_SWAPS", "user_swaps",
"MARGIN_BALANCE", "margin_balance",
"MARGIN_NET", "margin_net",
"MARGIN_MIN" "margin_min"
]) ])
Claim = generate_labeler_serializer("Claim", klass=types.Claim, labels=[ Claim = generate_labeler_serializer("Claim", klass=types.Claim, labels=[
"SYMBOL", "symbol",
"POSITION_STATUS", "position_status",
"AMOUNT", "amount",
"BASE_PRICE", "base_price",
"MARGIN_FUNDING", "margin_funding",
"MARGIN_FUNDING_TYPE", "margin_funding_type",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"POSITION_ID", "position_id",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"_PLACEHOLDER", "_PLACEHOLDER",
"POS_TYPE", "pos_type",
"_PLACEHOLDER", "_PLACEHOLDER",
"COLLATERAL", "collateral",
"MIN_COLLATERAL", "min_collateral",
"META" "meta"
]) ])
IncreaseInfo = generate_labeler_serializer("IncreaseInfo", klass=types.IncreaseInfo, labels=[ IncreaseInfo = generate_labeler_serializer("IncreaseInfo", klass=types.IncreaseInfo, labels=[
"MAX_POS", "max_pos",
"CURRENT_POS", "current_pos",
"BASE_CURRENCY_BALANCE", "base_currency_balance",
"TRADABLE_BALANCE_QUOTE_CURRENCY", "tradable_balance_quote_currency",
"TRADABLE_BALANCE_QUOTE_TOTAL", "tradable_balance_quote_total",
"TRADABLE_BALANCE_BASE_CURRENCY", "tradable_balance_base_currency",
"TRADABLE_BALANCE_BASE_TOTAL", "tradable_balance_base_total",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"FUNDING_AVAIL", "funding_avail",
"FUNDING_VALUE", "funding_value",
"FUNDING_REQUIRED", "funding_required",
"FUNDING_VALUE_CURRENCY", "funding_value_currency",
"FUNDING_REQUIRED_CURRENCY" "funding_required_currency"
]) ])
Increase = generate_labeler_serializer("Increase", klass=types.Increase, labels=[ Increase = generate_labeler_serializer("Increase", klass=types.Increase, labels=[
"SYMBOL", "symbol",
"_PLACEHOLDER", "_PLACEHOLDER",
"AMOUNT", "amount",
"BASE_PRICE" "base_price"
]) ])
PositionHistory = generate_labeler_serializer("PositionHistory", klass=types.PositionHistory, labels=[ PositionHistory = generate_labeler_serializer("PositionHistory", klass=types.PositionHistory, labels=[
"SYMBOL", "symbol",
"STATUS", "status",
"AMOUNT", "amount",
"BASE_PRICE", "base_price",
"FUNDING", "funding",
"FUNDING_TYPE", "funding_type",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"POSITION_ID", "position_id",
"MTS_CREATE", "mts_create",
"MTS_UPDATE" "mts_update"
]) ])
PositionSnapshot = generate_labeler_serializer("PositionSnapshot", klass=types.PositionSnapshot, labels=[ PositionSnapshot = generate_labeler_serializer("PositionSnapshot", klass=types.PositionSnapshot, labels=[
"SYMBOL", "symbol",
"STATUS", "status",
"AMOUNT", "amount",
"BASE_PRICE", "base_price",
"FUNDING", "funding",
"FUNDING_TYPE", "funding_type",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"POSITION_ID", "position_id",
"MTS_CREATE", "mts_create",
"MTS_UPDATE" "mts_update"
]) ])
PositionAudit = generate_labeler_serializer("PositionAudit", klass=types.PositionAudit, labels=[ PositionAudit = generate_labeler_serializer("PositionAudit", klass=types.PositionAudit, labels=[
"SYMBOL", "symbol",
"STATUS", "status",
"AMOUNT", "amount",
"BASE_PRICE", "base_price",
"FUNDING", "funding",
"FUNDING_TYPE", "funding_type",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"POSITION_ID", "position_id",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"_PLACEHOLDER", "_PLACEHOLDER",
"TYPE", "type",
"_PLACEHOLDER", "_PLACEHOLDER",
"COLLATERAL", "collateral",
"COLLATERAL_MIN", "collateral_min",
"META" "meta"
]) ])
DerivativePositionCollateral = generate_labeler_serializer("DerivativePositionCollateral", klass=types.DerivativePositionCollateral, labels=[ DerivativePositionCollateral = generate_labeler_serializer("DerivativePositionCollateral", klass=types.DerivativePositionCollateral, labels=[
"STATUS" "status"
]) ])
DerivativePositionCollateralLimits = generate_labeler_serializer("DerivativePositionCollateralLimits", klass=types.DerivativePositionCollateralLimits, labels=[ DerivativePositionCollateralLimits = generate_labeler_serializer("DerivativePositionCollateralLimits", klass=types.DerivativePositionCollateralLimits, labels=[
"MIN_COLLATERAL", "min_collateral",
"MAX_COLLATERAL" "max_collateral"
]) ])
#endregion #endregion

678
bfxapi/rest/types.py
View File

@@ -10,188 +10,188 @@ from .. utils.encoder import JSON
@dataclass @dataclass
class PlatformStatus(_Type): class PlatformStatus(_Type):
STATUS: int status: int
@dataclass @dataclass
class TradingPairTicker(_Type): class TradingPairTicker(_Type):
SYMBOL: Optional[str] symbol: Optional[str]
BID: float bid: float
BID_SIZE: float bid_size: float
ASK: float ask: float
ASK_SIZE: float ask_size: float
DAILY_CHANGE: float daily_change: float
DAILY_CHANGE_RELATIVE: float daily_change_relative: float
LAST_PRICE: float last_price: float
VOLUME: float volume: float
HIGH: float high: float
LOW: float low: float
@dataclass @dataclass
class FundingCurrencyTicker(_Type): class FundingCurrencyTicker(_Type):
SYMBOL: Optional[str] symbol: Optional[str]
FRR: float frr: float
BID: float bid: float
BID_PERIOD: int bid_period: int
BID_SIZE: float bid_size: float
ASK: float ask: float
ASK_PERIOD: int ask_period: int
ASK_SIZE: float ask_size: float
DAILY_CHANGE: float daily_change: float
DAILY_CHANGE_RELATIVE: float daily_change_relative: float
LAST_PRICE: float last_price: float
VOLUME: float volume: float
HIGH: float high: float
LOW: float low: float
FRR_AMOUNT_AVAILABLE: float frr_amount_available: float
@dataclass @dataclass
class TickersHistory(_Type): class TickersHistory(_Type):
SYMBOL: str symbol: str
BID: float bid: float
ASK: float ask: float
MTS: int mts: int
@dataclass @dataclass
class TradingPairTrade(_Type): class TradingPairTrade(_Type):
ID: int id: int
MTS: int mts: int
AMOUNT: float amount: float
PRICE: float price: float
@dataclass @dataclass
class FundingCurrencyTrade(_Type): class FundingCurrencyTrade(_Type):
ID: int id: int
MTS: int mts: int
AMOUNT: float amount: float
RATE: float rate: float
PERIOD: int period: int
@dataclass @dataclass
class TradingPairBook(_Type): class TradingPairBook(_Type):
PRICE: float price: float
COUNT: int count: int
AMOUNT: float amount: float
@dataclass @dataclass
class FundingCurrencyBook(_Type): class FundingCurrencyBook(_Type):
RATE: float rate: float
PERIOD: int period: int
COUNT: int count: int
AMOUNT: float amount: float
@dataclass @dataclass
class TradingPairRawBook(_Type): class TradingPairRawBook(_Type):
ORDER_ID: int order_id: int
PRICE: float price: float
AMOUNT: float amount: float
@dataclass @dataclass
class FundingCurrencyRawBook(_Type): class FundingCurrencyRawBook(_Type):
OFFER_ID: int offer_id: int
PERIOD: int period: int
RATE: float rate: float
AMOUNT: float amount: float
@dataclass @dataclass
class Statistic(_Type): class Statistic(_Type):
MTS: int mts: int
VALUE: float value: float
@dataclass @dataclass
class Candle(_Type): class Candle(_Type):
MTS: int mts: int
OPEN: float open: float
CLOSE: float close: float
HIGH: float high: float
LOW: float low: float
VOLUME: float volume: float
@dataclass @dataclass
class DerivativesStatus(_Type): class DerivativesStatus(_Type):
KEY: Optional[str] key: Optional[str]
MTS: int mts: int
DERIV_PRICE: float deriv_price: float
SPOT_PRICE: float spot_price: float
INSURANCE_FUND_BALANCE: float insurance_fund_balance: float
NEXT_FUNDING_EVT_TIMESTAMP_MS: int next_funding_evt_timestamp_ms: int
NEXT_FUNDING_ACCRUED: float next_funding_accrued: float
NEXT_FUNDING_STEP: int next_funding_step: int
CURRENT_FUNDING: float current_funding: float
MARK_PRICE: float mark_price: float
OPEN_INTEREST: float open_interest: float
CLAMP_MIN: float clamp_min: float
CLAMP_MAX: float clamp_max: float
@dataclass @dataclass
class Liquidation(_Type): class Liquidation(_Type):
POS_ID: int pos_id: int
MTS: int mts: int
SYMBOL: str symbol: str
AMOUNT: float amount: float
BASE_PRICE: float base_price: float
IS_MATCH: int is_match: int
IS_MARKET_SOLD: int is_market_sold: int
PRICE_ACQUIRED: float price_acquired: float
@dataclass @dataclass
class Leaderboard(_Type): class Leaderboard(_Type):
MTS: int mts: int
USERNAME: str username: str
RANKING: int ranking: int
VALUE: float value: float
TWITTER_HANDLE: Optional[str] twitter_handle: Optional[str]
@dataclass @dataclass
class FundingStatistic(_Type): class FundingStatistic(_Type):
TIMESTAMP: int timestamp: int
FRR: float frr: float
AVG_PERIOD: float avg_period: float
FUNDING_AMOUNT: float funding_amount: float
FUNDING_AMOUNT_USED: float funding_amount_used: float
FUNDING_BELOW_THRESHOLD: float funding_below_threshold: float
@dataclass @dataclass
class PulseProfile(_Type): class PulseProfile(_Type):
PUID: str puid: str
MTS: int mts: int
NICKNAME: str nickname: str
PICTURE: str picture: str
TEXT: str text: str
TWITTER_HANDLE: str twitter_handle: str
FOLLOWERS: int followers: int
FOLLOWING: int following: int
TIPPING_STATUS: int tipping_status: int
@dataclass @dataclass
class PulseMessage(_Type): class PulseMessage(_Type):
PID: str pid: str
MTS: int mts: int
PUID: str puid: str
TITLE: str title: str
CONTENT: str content: str
IS_PIN: int is_pin: int
IS_PUBLIC: int is_public: int
COMMENTS_DISABLED: int comments_disabled: int
TAGS: List[str] tags: List[str]
ATTACHMENTS: List[str] attachments: List[str]
META: List[JSON] meta: List[JSON]
LIKES: int likes: int
PROFILE: PulseProfile profile: PulseProfile
COMMENTS: int comments: int
@dataclass @dataclass
class TradingMarketAveragePrice(_Type): class TradingMarketAveragePrice(_Type):
PRICE_AVG: float price_avg: float
AMOUNT: float amount: float
@dataclass @dataclass
class FundingMarketAveragePrice(_Type): class FundingMarketAveragePrice(_Type):
RATE_AVG: float rate_avg: float
AMOUNT: float amount: float
@dataclass @dataclass
class FxRate(_Type): class FxRate(_Type):
CURRENT_RATE: float current_rate: float
#endregion #endregion
@@ -199,279 +199,299 @@ class FxRate(_Type):
@dataclass @dataclass
class Wallet(_Type): class Wallet(_Type):
WALLET_TYPE: str wallet_type: str
CURRENCY: str currency: str
BALANCE: float balance: float
UNSETTLED_INTEREST: float unsettled_interest: float
AVAILABLE_BALANCE: float available_balance: float
LAST_CHANGE: str last_change: str
TRADE_DETAILS: JSON trade_details: JSON
@dataclass @dataclass
class Order(_Type): class Order(_Type):
ID: int id: int
GID: int gid: int
CID: int cid: int
SYMBOL: str symbol: str
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
AMOUNT: float amount: float
AMOUNT_ORIG: float amount_orig: float
ORDER_TYPE: str order_type: str
TYPE_PREV: str type_prev: str
MTS_TIF: int mts_tif: int
FLAGS: int flags: int
ORDER_STATUS: str order_status: str
PRICE: float price: float
PRICE_AVG: float price_avg: float
PRICE_TRAILING: float price_trailing: float
PRICE_AUX_LIMIT: float price_aux_limit: float
NOTIFY: int notify: int
HIDDEN: int hidden: int
PLACED_ID: int placed_id: int
ROUTING: str routing: str
META: JSON meta: JSON
@dataclass @dataclass
class Position(_Type): class Position(_Type):
SYMBOL: str symbol: str
STATUS: str status: str
AMOUNT: float amount: float
BASE_PRICE: float base_price: float
MARGIN_FUNDING: float margin_funding: float
MARGIN_FUNDING_TYPE: int margin_funding_type: int
PL: float pl: float
PL_PERC: float pl_perc: float
PRICE_LIQ: float price_liq: float
LEVERAGE: float leverage: float
POSITION_ID: int position_id: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
TYPE: int type: int
COLLATERAL: float collateral: float
COLLATERAL_MIN: float collateral_min: float
META: JSON meta: JSON
@dataclass @dataclass
class FundingOffer(_Type): class FundingOffer(_Type):
ID: int id: int
SYMBOL: str symbol: str
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
AMOUNT: float amount: float
AMOUNT_ORIG: float amount_orig: float
OFFER_TYPE: str offer_type: str
FLAGS: int flags: int
OFFER_STATUS: str offer_status: str
RATE: float rate: float
PERIOD: int period: int
NOTIFY: bool notify: bool
HIDDEN: int hidden: int
RENEW: bool renew: bool
@dataclass @dataclass
class Trade(_Type): class Trade(_Type):
ID: int id: int
SYMBOL: str symbol: str
MTS_CREATE: int mts_create: int
ORDER_ID: int order_id: int
EXEC_AMOUNT: float exec_amount: float
EXEC_PRICE: float exec_price: float
ORDER_TYPE: str order_type: str
ORDER_PRICE: float order_price: float
MAKER:int maker:int
FEE: float fee: float
FEE_CURRENCY: str fee_currency: str
CID: int cid: int
@dataclass @dataclass
class OrderTrade(_Type): class OrderTrade(_Type):
ID: int id: int
SYMBOL: str symbol: str
MTS_CREATE: int mts_create: int
ORDER_ID: int order_id: int
EXEC_AMOUNT: float exec_amount: float
EXEC_PRICE: float exec_price: float
MAKER:int maker:int
FEE: float fee: float
FEE_CURRENCY: str fee_currency: str
CID: int cid: int
@dataclass @dataclass
class Ledger(_Type): class Ledger(_Type):
ID: int id: int
CURRENCY: str currency: str
MTS: int mts: int
AMOUNT: float amount: float
BALANCE: float balance: float
description: str description: str
@dataclass
class FundingLoan(_Type):
id: int
symbol: str
side: int
mts_create: int
mts_update: int
amount: float
flags: int
status: str
rate: float
period: int
mts_opening: int
mts_last_payout: int
notify: int
hidden: int
renew: int
rate_real: float
no_close: int
@dataclass @dataclass
class FundingCredit(_Type): class FundingCredit(_Type):
ID: int id: int
SYMBOL: str symbol: str
SIDE: int side: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
AMOUNT: float amount: float
FLAGS: int flags: int
STATUS: str status: str
RATE: float rate: float
PERIOD: int period: int
MTS_OPENING: int mts_opening: int
MTS_LAST_PAYOUT: int mts_last_payout: int
NOTIFY: int notify: int
HIDDEN: int hidden: int
RENEW: int renew: int
RATE_REAL: float rate_real: float
NO_CLOSE: int no_close: int
POSITION_PAIR: str position_pair: str
@dataclass @dataclass
class Transfer(_Type): class Transfer(_Type):
MTS: int mts: int
WALLET_FROM: str wallet_from: str
WALLET_TO: str wallet_to: str
CURRENCY: str currency: str
CURRENCY_TO: str currency_to: str
AMOUNT: int amount: int
@dataclass @dataclass
class Withdrawal(_Type): class Withdrawal(_Type):
WITHDRAWAL_ID: int withdrawal_id: int
METHOD: str method: str
PAYMENT_ID: str payment_id: str
WALLET: str wallet: str
AMOUNT: float amount: float
WITHDRAWAL_FEE: float withdrawal_fee: float
@dataclass @dataclass
class DepositAddress(_Type): class DepositAddress(_Type):
METHOD: str method: str
CURRENCY_CODE: str currency_code: str
ADDRESS: str address: str
POOL_ADDRESS: str pool_address: str
@dataclass @dataclass
class Invoice(_Type): class Invoice(_Type):
INVOICE_HASH: str invoice_hash: str
INVOICE: str invoice: str
AMOUNT: str amount: str
@dataclass @dataclass
class Movement(_Type): class Movement(_Type):
ID: str id: str
CURRENCY: str currency: str
CURRENCY_NAME: str currency_name: str
MTS_STARTED: int mts_started: int
MTS_UPDATED: int mts_updated: int
STATUS: str status: str
AMOUNT: int amount: int
FEES: int fees: int
DESTINATION_ADDRESS: str destination_address: str
TRANSACTION_ID: str transaction_id: str
WITHDRAW_TRANSACTION_NOTE: str withdraw_transaction_note: str
@dataclass @dataclass
class SymbolMarginInfo(_Type): class SymbolMarginInfo(_Type):
SYMBOL: str symbol: str
TRADABLE_BALANCE: float tradable_balance: float
GROSS_BALANCE: float gross_balance: float
BUY: float buy: float
SELL: float sell: float
@dataclass @dataclass
class BaseMarginInfo(_Type): class BaseMarginInfo(_Type):
USER_PL: float user_pl: float
USER_SWAPS: float user_swaps: float
MARGIN_BALANCE: float margin_balance: float
MARGIN_NET: float margin_net: float
MARGIN_MIN: float margin_min: float
@dataclass @dataclass
class Claim(_Type): class Claim(_Type):
SYMBOL: str symbol: str
POSITION_STATUS: str position_status: str
AMOUNT: float amount: float
BASE_PRICE: float base_price: float
MARGIN_FUNDING: float margin_funding: float
MARGIN_FUNDING_TYPE: int margin_funding_type: int
POSITION_ID: int position_id: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
POS_TYPE: int pos_type: int
COLLATERAL: str collateral: str
MIN_COLLATERAL: str min_collateral: str
META: JSON meta: JSON
@dataclass @dataclass
class IncreaseInfo(_Type): class IncreaseInfo(_Type):
MAX_POS: int max_pos: int
CURRENT_POS: float current_pos: float
BASE_CURRENCY_BALANCE: float base_currency_balance: float
TRADABLE_BALANCE_QUOTE_CURRENCY: float tradable_balance_quote_currency: float
TRADABLE_BALANCE_QUOTE_TOTAL: float tradable_balance_quote_total: float
TRADABLE_BALANCE_BASE_CURRENCY: float tradable_balance_base_currency: float
TRADABLE_BALANCE_BASE_TOTAL: float tradable_balance_base_total: float
FUNDING_AVAIL: float funding_avail: float
FUNDING_VALUE: float funding_value: float
FUNDING_REQUIRED: float funding_required: float
FUNDING_VALUE_CURRENCY: str funding_value_currency: str
FUNDING_REQUIRED_CURRENCY: str funding_required_currency: str
@dataclass @dataclass
class Increase(_Type): class Increase(_Type):
SYMBOL: str symbol: str
AMOUNT: float amount: float
BASE_PRICE: float base_price: float
@dataclass @dataclass
class PositionHistory(_Type): class PositionHistory(_Type):
SYMBOL: str symbol: str
STATUS: str status: str
AMOUNT: float amount: float
BASE_PRICE: float base_price: float
FUNDING: float funding: float
FUNDING_TYPE: int funding_type: int
POSITION_ID: int position_id: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
@dataclass @dataclass
class PositionSnapshot(_Type): class PositionSnapshot(_Type):
SYMBOL: str symbol: str
STATUS: str status: str
AMOUNT: float amount: float
BASE_PRICE: float base_price: float
FUNDING: float funding: float
FUNDING_TYPE: int funding_type: int
POSITION_ID: int position_id: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
@dataclass @dataclass
class PositionAudit(_Type): class PositionAudit(_Type):
SYMBOL: str symbol: str
STATUS: str status: str
AMOUNT: float amount: float
BASE_PRICE: float base_price: float
FUNDING: float funding: float
FUNDING_TYPE: int funding_type: int
POSITION_ID: int position_id: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
TYPE: int type: int
COLLATERAL: float collateral: float
COLLATERAL_MIN: float collateral_min: float
META: JSON meta: JSON
@dataclass @dataclass
class DerivativePositionCollateral(_Type): class DerivativePositionCollateral(_Type):
STATUS: int status: int
@dataclass @dataclass
class DerivativePositionCollateralLimits(_Type): class DerivativePositionCollateralLimits(_Type):
MIN_COLLATERAL: float min_collateral: float
MAX_COLLATERAL: float max_collateral: float
#endregion #endregion

370
bfxapi/websocket/serializers.py
View File

@@ -7,111 +7,111 @@ from .. notification import _Notification
#region Serializers definition for Websocket Public Channels #region Serializers definition for Websocket Public Channels
TradingPairTicker = generate_labeler_serializer("TradingPairTicker", klass=types.TradingPairTicker, labels=[ TradingPairTicker = generate_labeler_serializer("TradingPairTicker", klass=types.TradingPairTicker, labels=[
"BID", "bid",
"BID_SIZE", "bid_size",
"ASK", "ask",
"ASK_SIZE", "ask_size",
"DAILY_CHANGE", "daily_change",
"DAILY_CHANGE_RELATIVE", "daily_change_relative",
"LAST_PRICE", "last_price",
"VOLUME", "volume",
"HIGH", "high",
"LOW" "low"
]) ])
FundingCurrencyTicker = generate_labeler_serializer("FundingCurrencyTicker", klass=types.FundingCurrencyTicker, labels=[ FundingCurrencyTicker = generate_labeler_serializer("FundingCurrencyTicker", klass=types.FundingCurrencyTicker, labels=[
"FRR", "frr",
"BID", "bid",
"BID_PERIOD", "bid_period",
"BID_SIZE", "bid_size",
"ASK", "ask",
"ASK_PERIOD", "ask_period",
"ASK_SIZE", "ask_size",
"DAILY_CHANGE", "daily_change",
"DAILY_CHANGE_RELATIVE", "daily_change_relative",
"LAST_PRICE", "last_price",
"VOLUME", "volume",
"HIGH", "high",
"LOW" "low"
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"FRR_AMOUNT_AVAILABLE" "frr_amount_available"
]) ])
TradingPairTrade = generate_labeler_serializer("TradingPairTrade", klass=types.TradingPairTrade, labels=[ TradingPairTrade = generate_labeler_serializer("TradingPairTrade", klass=types.TradingPairTrade, labels=[
"ID", "id",
"MTS", "mts",
"AMOUNT", "amount",
"PRICE" "price"
]) ])
FundingCurrencyTrade = generate_labeler_serializer("FundingCurrencyTrade", klass=types.FundingCurrencyTrade, labels=[ FundingCurrencyTrade = generate_labeler_serializer("FundingCurrencyTrade", klass=types.FundingCurrencyTrade, labels=[
"ID", "id",
"MTS", "mts",
"AMOUNT", "amount",
"RATE", "rate",
"PERIOD" "period"
]) ])
TradingPairBook = generate_labeler_serializer("TradingPairBook", klass=types.TradingPairBook, labels=[ TradingPairBook = generate_labeler_serializer("TradingPairBook", klass=types.TradingPairBook, labels=[
"PRICE", "price",
"COUNT", "count",
"AMOUNT" "amount"
]) ])
FundingCurrencyBook = generate_labeler_serializer("FundingCurrencyBook", klass=types.FundingCurrencyBook, labels=[ FundingCurrencyBook = generate_labeler_serializer("FundingCurrencyBook", klass=types.FundingCurrencyBook, labels=[
"RATE", "rate",
"PERIOD", "period",
"COUNT", "count",
"AMOUNT" "amount"
]) ])
TradingPairRawBook = generate_labeler_serializer("TradingPairRawBook", klass=types.TradingPairRawBook, labels=[ TradingPairRawBook = generate_labeler_serializer("TradingPairRawBook", klass=types.TradingPairRawBook, labels=[
"ORDER_ID", "order_id",
"PRICE", "price",
"AMOUNT" "amount"
]) ])
FundingCurrencyRawBook = generate_labeler_serializer("FundingCurrencyRawBook", klass=types.FundingCurrencyRawBook, labels=[ FundingCurrencyRawBook = generate_labeler_serializer("FundingCurrencyRawBook", klass=types.FundingCurrencyRawBook, labels=[
"OFFER_ID", "offer_id",
"PERIOD", "period",
"RATE", "rate",
"AMOUNT" "amount"
]) ])
Candle = generate_labeler_serializer("Candle", klass=types.Candle, labels=[ Candle = generate_labeler_serializer("Candle", klass=types.Candle, labels=[
"MTS", "mts",
"OPEN", "open",
"CLOSE", "close",
"HIGH", "high",
"LOW", "low",
"VOLUME" "volume"
]) ])
DerivativesStatus = generate_labeler_serializer("DerivativesStatus", klass=types.DerivativesStatus, labels=[ DerivativesStatus = generate_labeler_serializer("DerivativesStatus", klass=types.DerivativesStatus, labels=[
"TIME_MS", "time_ms",
"_PLACEHOLDER", "_PLACEHOLDER",
"DERIV_PRICE", "deriv_price",
"SPOT_PRICE", "spot_price",
"_PLACEHOLDER", "_PLACEHOLDER",
"INSURANCE_FUND_BALANCE", "insurance_fund_balance",
"_PLACEHOLDER", "_PLACEHOLDER",
"NEXT_FUNDING_EVT_TIMESTAMP_MS", "next_funding_evt_timestamp_ms",
"NEXT_FUNDING_ACCRUED", "next_funding_accrued",
"NEXT_FUNDING_STEP", "next_funding_step",
"_PLACEHOLDER", "_PLACEHOLDER",
"CURRENT_FUNDING" "current_funding"
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"MARK_PRICE", "mark_price",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"OPEN_INTEREST", "open_interest",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"CLAMP_MIN", "clamp_min",
"CLAMP_MAX" "clamp_max"
]) ])
#endregion #endregion
@@ -119,179 +119,179 @@ DerivativesStatus = generate_labeler_serializer("DerivativesStatus", klass=types
#region Serializers definition for Websocket Authenticated Channels #region Serializers definition for Websocket Authenticated Channels
Order = generate_labeler_serializer("Order", klass=types.Order, labels=[ Order = generate_labeler_serializer("Order", klass=types.Order, labels=[
"ID", "id",
"GID", "gid",
"CID", "cid",
"SYMBOL", "symbol",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"AMOUNT", "amount",
"AMOUNT_ORIG", "amount_orig",
"ORDER_TYPE", "order_type",
"TYPE_PREV", "type_prev",
"MTS_TIF", "mts_tif",
"_PLACEHOLDER", "_PLACEHOLDER",
"FLAGS", "flags",
"ORDER_STATUS", "order_status",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"PRICE", "price",
"PRICE_AVG", "price_avg",
"PRICE_TRAILING", "price_trailing",
"PRICE_AUX_LIMIT", "price_aux_limit",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"NOTIFY", "notify",
"HIDDEN", "hidden",
"PLACED_ID", "placed_id",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"ROUTING", "routing",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"META" "meta"
]) ])
Position = generate_labeler_serializer("Position", klass=types.Position, labels=[ Position = generate_labeler_serializer("Position", klass=types.Position, labels=[
"SYMBOL", "symbol",
"STATUS", "status",
"AMOUNT", "amount",
"BASE_PRICE", "base_price",
"MARGIN_FUNDING", "margin_funding",
"MARGIN_FUNDING_TYPE", "margin_funding_type",
"PL", "pl",
"PL_PERC", "pl_perc",
"PRICE_LIQ", "price_liq",
"LEVERAGE", "leverage",
"FLAG", "flag",
"POSITION_ID", "position_id",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"_PLACEHOLDER", "_PLACEHOLDER",
"TYPE", "type",
"_PLACEHOLDER", "_PLACEHOLDER",
"COLLATERAL", "collateral",
"COLLATERAL_MIN", "collateral_min",
"META" "meta"
]) ])
TradeExecuted = generate_labeler_serializer("TradeExecuted", klass=types.TradeExecuted, labels=[ TradeExecuted = generate_labeler_serializer("TradeExecuted", klass=types.TradeExecuted, labels=[
"ID", "id",
"SYMBOL", "symbol",
"MTS_CREATE", "mts_create",
"ORDER_ID", "order_id",
"EXEC_AMOUNT", "exec_amount",
"EXEC_PRICE", "exec_price",
"ORDER_TYPE", "order_type",
"ORDER_PRICE", "order_price",
"MAKER", "maker",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"CID" "cid"
]) ])
TradeExecutionUpdate = generate_labeler_serializer("TradeExecutionUpdate", klass=types.TradeExecutionUpdate, labels=[ TradeExecutionUpdate = generate_labeler_serializer("TradeExecutionUpdate", klass=types.TradeExecutionUpdate, labels=[
"ID", "id",
"SYMBOL", "symbol",
"MTS_CREATE", "mts_create",
"ORDER_ID", "order_id",
"EXEC_AMOUNT", "exec_amount",
"EXEC_PRICE", "exec_price",
"ORDER_TYPE", "order_type",
"ORDER_PRICE", "order_price",
"MAKER", "maker",
"FEE", "fee",
"FEE_CURRENCY", "fee_currency",
"CID" "cid"
]) ])
FundingOffer = generate_labeler_serializer("FundingOffer", klass=types.FundingOffer, labels=[ FundingOffer = generate_labeler_serializer("FundingOffer", klass=types.FundingOffer, labels=[
"ID", "id",
"SYMBOL", "symbol",
"MTS_CREATED", "mts_created",
"MTS_UPDATED", "mts_updated",
"AMOUNT", "amount",
"AMOUNT_ORIG", "amount_orig",
"OFFER_TYPE", "offer_type",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"FLAGS", "flags",
"STATUS", "status",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"RATE", "rate",
"PERIOD", "period",
"NOTIFY", "notify",
"HIDDEN", "hidden",
"_PLACEHOLDER", "_PLACEHOLDER",
"RENEW", "renew",
"_PLACEHOLDER" "_PLACEHOLDER"
]) ])
FundingCredit = generate_labeler_serializer("FundingCredit", klass=types.FundingCredit, labels=[ FundingCredit = generate_labeler_serializer("FundingCredit", klass=types.FundingCredit, labels=[
"ID", "id",
"SYMBOL", "symbol",
"SIDE", "side",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"AMOUNT", "amount",
"FLAGS", "flags",
"STATUS", "status",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"RATE", "rate",
"PERIOD", "period",
"MTS_OPENING", "mts_opening",
"MTS_LAST_PAYOUT", "mts_last_payout",
"NOTIFY", "notify",
"HIDDEN", "hidden",
"_PLACEHOLDER", "_PLACEHOLDER",
"RENEW", "renew",
"RATE_REAL", "rate_real",
"NO_CLOSE", "no_close",
"POSITION_PAIR" "position_pair"
]) ])
FundingLoan = generate_labeler_serializer("FundingLoan", klass=types.FundingLoan, labels=[ FundingLoan = generate_labeler_serializer("FundingLoan", klass=types.FundingLoan, labels=[
"ID", "id",
"SYMBOL", "symbol",
"SIDE", "side",
"MTS_CREATE", "mts_create",
"MTS_UPDATE", "mts_update",
"AMOUNT", "amount",
"FLAGS", "flags",
"STATUS", "status",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"_PLACEHOLDER", "_PLACEHOLDER",
"RATE", "rate",
"PERIOD", "period",
"MTS_OPENING", "mts_opening",
"MTS_LAST_PAYOUT", "mts_last_payout",
"NOTIFY", "notify",
"HIDDEN", "hidden",
"_PLACEHOLDER", "_PLACEHOLDER",
"RENEW", "renew",
"RATE_REAL", "rate_real",
"NO_CLOSE" "no_close"
]) ])
Wallet = generate_labeler_serializer("Wallet", klass=types.Wallet, labels=[ Wallet = generate_labeler_serializer("Wallet", klass=types.Wallet, labels=[
"WALLET_TYPE", "wallet_type",
"CURRENCY", "currency",
"BALANCE", "balance",
"UNSETTLED_INTEREST", "unsettled_interest",
"BALANCE_AVAILABLE", "balance_available",
"DESCRIPTION", "description",
"META" "meta"
]) ])
BalanceInfo = generate_labeler_serializer("BalanceInfo", klass=types.BalanceInfo, labels=[ BalanceInfo = generate_labeler_serializer("BalanceInfo", klass=types.BalanceInfo, labels=[
"AUM", "aum",
"AUM_NET", "aum_net",
]) ])
#endregion #endregion

368
bfxapi/websocket/types.py
View File

@@ -10,246 +10,246 @@ from .. utils.encoder import JSON
@dataclass @dataclass
class TradingPairTicker(_Type): class TradingPairTicker(_Type):
BID: float bid: float
BID_SIZE: float bid_size: float
ASK: float ask: float
ASK_SIZE: float ask_size: float
DAILY_CHANGE: float daily_change: float
DAILY_CHANGE_RELATIVE: float daily_change_relative: float
LAST_PRICE: float last_price: float
VOLUME: float volume: float
HIGH: float high: float
LOW: float low: float
@dataclass @dataclass
class FundingCurrencyTicker(_Type): class FundingCurrencyTicker(_Type):
FRR: float frr: float
BID: float bid: float
BID_PERIOD: int bid_period: int
BID_SIZE: float bid_size: float
ASK: float ask: float
ASK_PERIOD: int ask_period: int
ASK_SIZE: float ask_size: float
DAILY_CHANGE: float daily_change: float
DAILY_CHANGE_RELATIVE: float daily_change_relative: float
LAST_PRICE: float last_price: float
VOLUME: float volume: float
HIGH: float high: float
LOW: float low: float
FRR_AMOUNT_AVAILABLE: float frr_amount_available: float
@dataclass @dataclass
class TradingPairTrade(_Type): class TradingPairTrade(_Type):
ID: int id: int
MTS: int mts: int
AMOUNT: float amount: float
PRICE: float price: float
@dataclass @dataclass
class FundingCurrencyTrade(_Type): class FundingCurrencyTrade(_Type):
ID: int id: int
MTS: int mts: int
AMOUNT: float amount: float
RATE: float rate: float
PERIOD: int period: int
@dataclass @dataclass
class TradingPairBook(_Type): class TradingPairBook(_Type):
PRICE: float price: float
COUNT: int count: int
AMOUNT: float amount: float
@dataclass @dataclass
class FundingCurrencyBook(_Type): class FundingCurrencyBook(_Type):
RATE: float rate: float
PERIOD: int period: int
COUNT: int count: int
AMOUNT: float amount: float
@dataclass @dataclass
class TradingPairRawBook(_Type): class TradingPairRawBook(_Type):
ORDER_ID: int order_id: int
PRICE: float price: float
AMOUNT: float amount: float
@dataclass @dataclass
class FundingCurrencyRawBook(_Type): class FundingCurrencyRawBook(_Type):
OFFER_ID: int offer_id: int
PERIOD: int period: int
RATE: float rate: float
AMOUNT: float amount: float
@dataclass @dataclass
class Candle(_Type): class Candle(_Type):
MTS: int mts: int
OPEN: float open: float
CLOSE: float close: float
HIGH: float high: float
LOW: float low: float
VOLUME: float volume: float
@dataclass @dataclass
class DerivativesStatus(_Type): class DerivativesStatus(_Type):
TIME_MS: int time_ms: int
DERIV_PRICE: float deriv_price: float
SPOT_PRICE: float spot_price: float
INSURANCE_FUND_BALANCE: float insurance_fund_balance: float
NEXT_FUNDING_EVT_TIMESTAMP_MS: int next_funding_evt_timestamp_ms: int
NEXT_FUNDING_ACCRUED: float next_funding_accrued: float
NEXT_FUNDING_STEP: int next_funding_step: int
CURRENT_FUNDING: float current_funding: float
MARK_PRICE: float mark_price: float
OPEN_INTEREST: float open_interest: float
CLAMP_MIN: float clamp_min: float
CLAMP_MAX: float clamp_max: float
#endregion #endregion
#region Type hinting for Websocket Authenticated Channels #region Type hinting for Websocket Authenticated Channels
@dataclass @dataclass
class Order(_Type): class Order(_Type):
ID: int id: int
GID: int gid: int
CID: int cid: int
SYMBOL: str symbol: str
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
AMOUNT: float amount: float
AMOUNT_ORIG: float amount_orig: float
ORDER_TYPE: str order_type: str
TYPE_PREV: str type_prev: str
MTS_TIF: int mts_tif: int
FLAGS: int flags: int
ORDER_STATUS: str order_status: str
PRICE: float price: float
PRICE_AVG: float price_avg: float
PRICE_TRAILING: float price_trailing: float
PRICE_AUX_LIMIT: float price_aux_limit: float
NOTIFY: int notify: int
HIDDEN: int hidden: int
PLACED_ID: int placed_id: int
ROUTING: str routing: str
META: JSON meta: JSON
@dataclass @dataclass
class Position(_Type): class Position(_Type):
SYMBOL: str symbol: str
STATUS: str status: str
AMOUNT: float amount: float
BASE_PRICE: float base_price: float
MARGIN_FUNDING: float margin_funding: float
MARGIN_FUNDING_TYPE: int margin_funding_type: int
PL: float pl: float
PL_PERC: float pl_perc: float
PRICE_LIQ: float price_liq: float
LEVERAGE: float leverage: float
POSITION_ID: int position_id: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
TYPE: int type: int
COLLATERAL: float collateral: float
COLLATERAL_MIN: float collateral_min: float
META: JSON meta: JSON
@dataclass @dataclass
class TradeExecuted(_Type): class TradeExecuted(_Type):
ID: int id: int
SYMBOL: str symbol: str
MTS_CREATE: int mts_create: int
ORDER_ID: int order_id: int
EXEC_AMOUNT: float exec_amount: float
EXEC_PRICE: float exec_price: float
ORDER_TYPE: str order_type: str
ORDER_PRICE: float order_price: float
MAKER:int maker:int
CID: int cid: int
@dataclass @dataclass
class TradeExecutionUpdate(_Type): class TradeExecutionUpdate(_Type):
ID: int id: int
SYMBOL: str symbol: str
MTS_CREATE: int mts_create: int
ORDER_ID: int order_id: int
EXEC_AMOUNT: float exec_amount: float
EXEC_PRICE: float exec_price: float
ORDER_TYPE: str order_type: str
ORDER_PRICE: float order_price: float
MAKER:int maker:int
FEE: float fee: float
FEE_CURRENCY: str fee_currency: str
CID: int cid: int
@dataclass @dataclass
class FundingOffer(_Type): class FundingOffer(_Type):
ID: int id: int
SYMBOL: str symbol: str
MTS_CREATED: int mts_created: int
MTS_UPDATED: int mts_updated: int
AMOUNT: float amount: float
AMOUNT_ORIG: float amount_orig: float
OFFER_TYPE: str offer_type: str
FLAGS: int flags: int
STATUS: str status: str
RATE: float rate: float
PERIOD: int period: int
NOTIFY: int notify: int
HIDDEN: int hidden: int
RENEW: int renew: int
@dataclass @dataclass
class FundingCredit(_Type): class FundingCredit(_Type):
ID: int id: int
SYMBOL: str symbol: str
SIDE: int side: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
AMOUNT: float amount: float
FLAGS: int flags: int
STATUS: str status: str
RATE: float rate: float
PERIOD: int period: int
MTS_OPENING: int mts_opening: int
MTS_LAST_PAYOUT: int mts_last_payout: int
NOTIFY: int notify: int
HIDDEN: int hidden: int
RENEW: int renew: int
RATE_REAL: float rate_real: float
NO_CLOSE: int no_close: int
POSITION_PAIR: str position_pair: str
@dataclass @dataclass
class FundingLoan(_Type): class FundingLoan(_Type):
ID: int id: int
SYMBOL: str symbol: str
SIDE: int side: int
MTS_CREATE: int mts_create: int
MTS_UPDATE: int mts_update: int
AMOUNT: float amount: float
FLAGS: int flags: int
STATUS: str status: str
RATE: float rate: float
PERIOD: int period: int
MTS_OPENING: int mts_opening: int
MTS_LAST_PAYOUT: int mts_last_payout: int
NOTIFY: int notify: int
HIDDEN: int hidden: int
RENEW: int renew: int
RATE_REAL: float rate_real: float
NO_CLOSE: int no_close: int
@dataclass @dataclass
class Wallet(_Type): class Wallet(_Type):
WALLET_TYPE: str wallet_type: str
CURRENCY: str currency: str
BALANCE: float balance: float
UNSETTLED_INTEREST: float unsettled_interest: float
BALANCE_AVAILABLE: float balance_available: float
DESCRIPTION: str description: str
META: JSON meta: JSON
@dataclass @dataclass
class BalanceInfo(_Type): class BalanceInfo(_Type):
AUM: float aum: float
AUM_NET: float aum_net: float
#endregion #endregion

4
examples/rest/claim_position.py
View File

@@ -15,5 +15,5 @@ open_margin_positions = bfx.rest.auth.get_positions()
# claim all positions # claim all positions
for position in open_margin_positions: for position in open_margin_positions:
print(f"Position {position}") print(f"Position {position}")
claim = bfx.rest.auth.claim_position(position.POSITION_ID, amount=0.000001) claim = bfx.rest.auth.claim_position(position.position_id, amount=0.000001)
print(f"Claim {claim.NOTIFY_INFO}") print(f"Claim {claim.notify_info}")

4
examples/rest/create_order.py
View File

@@ -25,7 +25,7 @@ print("Submit Order Notification:", submitted_order)
# Update it # Update it
updated_order = bfx.rest.auth.update_order( updated_order = bfx.rest.auth.update_order(
id=submitted_order.NOTIFY_INFO.ID, id=submitted_order.notify_info.id,
amount="0.020", amount="0.020",
price="10100" price="10100"
) )
@@ -33,6 +33,6 @@ updated_order = bfx.rest.auth.update_order(
print("Update Order Notification:", updated_order) print("Update Order Notification:", updated_order)
# Delete it # Delete it
canceled_order = bfx.rest.auth.cancel_order(id=submitted_order.NOTIFY_INFO.ID) canceled_order = bfx.rest.auth.cancel_order(id=submitted_order.notify_info.id)
print("Cancel Order Notification:", canceled_order) print("Cancel Order Notification:", canceled_order)

2
examples/rest/derivatives.py
View File

@@ -27,5 +27,5 @@ print(f"Limits {limits}")
# Update position collateral # Update position collateral
response = bfx.rest.auth.set_derivative_position_collateral(symbol="tBTCF0:USTF0", collateral=50) response = bfx.rest.auth.set_derivative_position_collateral(symbol="tBTCF0:USTF0", collateral=50)
print(response.STATUS) print(response.status)

6
examples/rest/extra_calcs.py
View File

@@ -12,7 +12,7 @@ t_symbol_response = bfx.rest.public.get_trading_market_average_price(
price_limit="20000.5" price_limit="20000.5"
) )
print(t_symbol_response.PRICE_AVG) print(t_symbol_response.price_avg)
f_symbol_response = bfx.rest.public.get_funding_market_average_price( f_symbol_response = bfx.rest.public.get_funding_market_average_price(
symbol="fUSD", symbol="fUSD",
@@ -21,8 +21,8 @@ f_symbol_response = bfx.rest.public.get_funding_market_average_price(
rate_limit="0.00015" rate_limit="0.00015"
) )
print(f_symbol_response.RATE_AVG) print(f_symbol_response.rate_avg)
fx_rate = bfx.rest.public.get_fx_rate(ccy1="USD", ccy2="EUR") fx_rate = bfx.rest.public.get_fx_rate(ccy1="USD", ccy2="EUR")
print(fx_rate.CURRENT_RATE) print(fx_rate.current_rate)

2
examples/rest/get_authenticated_data.py
View File

@@ -69,7 +69,7 @@ def log_funding_loans():
def log_funding_loans_history(): def log_funding_loans_history():
loans = bfx.rest.auth.get_funding_loan_history(symbol='fUSD', start=0, end=now) loans = bfx.rest.auth.get_funding_loans_history(symbol='fUSD', start=0, end=now)
print("Funding loan history:") print("Funding loan history:")
[print(l) for l in loans] [print(l) for l in loans]

6
examples/rest/get_pulse_data.py
View File

@@ -14,9 +14,9 @@ messages = bfx.rest.public.get_pulse_history(end=now, limit=100)
for message in messages: for message in messages:
print(f"Message: {message}") print(f"Message: {message}")
print(message.CONTENT) print(message.content)
print(message.PROFILE.PICTURE) print(message.profile.picture)
profile = bfx.rest.public.get_pulse_profile("News") profile = bfx.rest.public.get_pulse_profile("News")
print(f"Profile: {profile}") print(f"Profile: {profile}")
print(f"Profile picture: {profile.PICTURE}") print(f"Profile picture: {profile.picture}")

2
examples/rest/increase_position.py
View File

@@ -15,4 +15,4 @@ print(increase_info)
# increase a margin position # increase a margin position
notification = bfx.rest.auth.increase_position(symbol="tBTCUSD", amount=0.0001) notification = bfx.rest.auth.increase_position(symbol="tBTCUSD", amount=0.0001)
print(notification.NOTIFY_INFO) print(notification.notify_info)

8
examples/rest/transfer_wallet.py
View File

@@ -12,20 +12,20 @@ bfx = Client(
def transfer_wallet(): def transfer_wallet():
response = bfx.rest.auth.submit_wallet_transfer(from_wallet="exchange", to_wallet="funding", from_currency="ETH", to_currency="ETH", amount=0.001) response = bfx.rest.auth.submit_wallet_transfer(from_wallet="exchange", to_wallet="funding", from_currency="ETH", to_currency="ETH", amount=0.001)
print("Transfer:", response.NOTIFY_INFO) print("Transfer:", response.notify_info)
def get_existing_deposit_address(): def get_existing_deposit_address():
response = bfx.rest.auth.get_deposit_address(wallet="exchange", method="bitcoin", renew=False) response = bfx.rest.auth.get_deposit_address(wallet="exchange", method="bitcoin", renew=False)
print("Address:", response.NOTIFY_INFO) print("Address:", response.notify_info)
def create_new_deposit_address(): def create_new_deposit_address():
response = bfx.rest.auth.get_deposit_address(wallet="exchange", method="bitcoin", renew=True) response = bfx.rest.auth.get_deposit_address(wallet="exchange", method="bitcoin", renew=True)
print("Address:", response.NOTIFY_INFO) print("Address:", response.notify_info)
def withdraw(): def withdraw():
# tetheruse = Tether (ERC20) # tetheruse = Tether (ERC20)
response = bfx.rest.auth.submit_wallet_withdraw(wallet="exchange", method="tetheruse", amount=1, address="0x742d35Cc6634C0532925a3b844Bc454e4438f44e") response = bfx.rest.auth.submit_wallet_withdraw(wallet="exchange", method="tetheruse", amount=1, address="0x742d35Cc6634C0532925a3b844Bc454e4438f44e")
print("Address:", response.NOTIFY_INFO) print("Address:", response.notify_info)
def create_lighting_network_deposit_address(): def create_lighting_network_deposit_address():
invoice = bfx.rest.auth.get_deposit_invoice(wallet="funding", currency="LNX", amount=0.001) invoice = bfx.rest.auth.get_deposit_invoice(wallet="funding", currency="LNX", amount=0.001)

2
examples/websocket/order_book.py
View File

@@ -19,7 +19,7 @@ class OrderBook(object):
} }
def update(self, symbol: str, data: TradingPairBook) -> None: def update(self, symbol: str, data: TradingPairBook) -> None:
price, count, amount = data.PRICE, data.COUNT, data.AMOUNT price, count, amount = data.price, data.count, data.amount
kind = (amount > 0) and "bids" or "asks" kind = (amount > 0) and "bids" or "asks"

2
examples/websocket/raw_order_book.py
View File

@@ -19,7 +19,7 @@ class RawOrderBook(object):
} }
def update(self, symbol: str, data: TradingPairRawBook) -> None: def update(self, symbol: str, data: TradingPairRawBook) -> None:
order_id, price, amount = data.ORDER_ID, data.PRICE, data.AMOUNT order_id, price, amount = data.order_id, data.price, data.amount
kind = (amount > 0) and "bids" or "asks" kind = (amount > 0) and "bids" or "asks"