def format_trades(trades):
ret_val = []
for trade in trades:
sum_trades = [
t for t in trades if t["symbol"] == trade["symbol"] and
t["orderId"] == trade["orderId"] and t["price"] == trade["price"]
]
if not sum_trades:
continue
amount = sum(Decimal(str(t["qty"])) for t in sum_trades)
time = sum_trades[-1]["time"]
commission = sum(Decimal(str(t["commission"])) for t in sum_trades)
ret_val.append(
Trade(
trading_pair=convert_from_exchange_trading_pair(
trade["symbol"]),
side=TradeType.BUY if trade["isBuyer"] else TradeType.SELL,
price=Decimal(str(trade["price"])),
amount=amount,
order_type=None,
market=convert_from_exchange_trading_pair(trade["symbol"]),
timestamp=int(time),
trade_fee=TradeFee(0.0,
[(trade["commissionAsset"], commission)]),
))
trades = [t for t in trades if t not in sum_trades]
return ret_val
async def fetch_binance_trading_pairs(self) -> List[str]:
try:
from hummingbot.connector.exchange.binance.binance_utils import convert_from_exchange_trading_pair
client: aiohttp.ClientSession = self.http_client()
async with client.get(BINANCE_ENDPOINT,
timeout=API_CALL_TIMEOUT) as response:
if response.status == 200:
data = await response.json()
raw_trading_pairs = [
d["symbol"] for d in data["symbols"]
if d["status"] == "TRADING"
]
trading_pair_list: List[str] = []
for raw_trading_pair in raw_trading_pairs:
converted_trading_pair: Optional[str] = \
convert_from_exchange_trading_pair(raw_trading_pair)
if converted_trading_pair is not None:
trading_pair_list.append(converted_trading_pair)
else:
self.logger().debug(
f"Could not parse the trading pair {raw_trading_pair}, skipping it..."
)
return trading_pair_list
except Exception:
# Do nothing if the request fails -- there will be no autocomplete for binance trading pairs
pass
return []
async def fetch_kraken_trading_pairs() -> List[str]:
try:
async with aiohttp.ClientSession() as client:
async with client.get(KRAKEN_ENDPOINT,
timeout=API_CALL_TIMEOUT) as response:
if response.status == 200:
from hummingbot.connector.exchange.kraken.kraken_utils import convert_from_exchange_trading_pair
data: Dict[str, Any] = await response.json()
raw_pairs = data.get("result", [])
converted_pairs: List[str] = []
for pair, details in raw_pairs.items():
if "." not in pair:
try:
wsname = details[
"wsname"] # pair in format BASE/QUOTE
converted_pairs.append(
convert_from_exchange_trading_pair(
wsname))
except IOError:
pass
return [item for item in converted_pairs]
except Exception:
pass
# Do nothing if the request fails -- there will be no autocomplete for kraken trading pairs
return []
async def fetch_huobi_trading_pairs(self) -> List[str]:
try:
from hummingbot.connector.exchange.huobi.huobi_utils import convert_from_exchange_trading_pair
client: aiohttp.ClientSession = self.http_client()
async with client.get(HUOBI_ENDPOINT,
timeout=API_CALL_TIMEOUT) as response:
if response.status == 200:
all_trading_pairs: Dict[str, Any] = await response.json()
valid_trading_pairs: list = []
for item in all_trading_pairs["data"]:
if item["state"] == "online":
valid_trading_pairs.append(item["symbol"])
trading_pair_list: List[str] = []
for raw_trading_pair in valid_trading_pairs:
converted_trading_pair: Optional[str] = \
convert_from_exchange_trading_pair(raw_trading_pair)
if converted_trading_pair is not None:
trading_pair_list.append(converted_trading_pair)
else:
self.logger().debug(
f"Could not parse the trading pair {raw_trading_pair}, skipping it..."
)
return trading_pair_list
except Exception:
# Do nothing if the request fails -- there will be no autocomplete for huobi trading pairs
pass
return []
async def fetch_eterbase_trading_pairs(self) -> List[str]:
try:
from hummingbot.connector.exchange.eterbase.eterbase_utils import convert_from_exchange_trading_pair
client: aiohttp.ClientSession() = self.http_client()
async with client.get(ETERBASE_ENDPOINT,
timeout=API_CALL_TIMEOUT) as response:
if response.status == 200:
markets = await response.json()
raw_trading_pairs: List[str] = list(
map(
lambda trading_market: trading_market.get('symbol'
),
filter(
lambda details: details.get('state') ==
'Trading', markets)))
trading_pair_list: List[str] = []
for raw_trading_pair in raw_trading_pairs:
converted_trading_pair: Optional[str] = \
convert_from_exchange_trading_pair(raw_trading_pair)
if converted_trading_pair is not None:
trading_pair_list.append(converted_trading_pair)
else:
self.logger().debug(
f"Could not parse the trading pair {raw_trading_pair}, skipping it..."
)
return trading_pair_list
except Exception:
pass
# Do nothing if the request fails -- there will be no autocomplete for eterbase trading pairs
return []
async def get_active_campaigns(exchange: str, trading_pairs: List[str] = []) -> Dict[int, CampaignSummary]:
campaigns = {}
async with aiohttp.ClientSession() as client:
url = f"{PARROT_MINER_BASE_URL}campaigns"
resp = await client.get(url)
resp_json = await resp.json()
for campaign_retval in resp_json:
for market in campaign_retval["markets"]:
if market["exchange_name"] != exchange:
continue
t_pair = market["trading_pair"]
# So far we have only 2 exchanges for mining Binance and Kucoin, Kucoin doesn't require conversion.
# In the future we should create a general approach for this, e.g. move all convert trading pair fn to
# utils.py and import the function dynamically in hummingbot/client/settings.py
if exchange == "binance":
t_pair = convert_from_exchange_trading_pair(t_pair)
if trading_pairs and t_pair not in trading_pairs:
continue
campaign = CampaignSummary()
campaign.market_id = int(market["id"])
campaign.trading_pair = t_pair
campaign.exchange_name = market["exchange_name"]
campaigns[campaign.market_id] = campaign
for bounty_period in campaign_retval["bounty_periods"]:
for payout in bounty_period["payout_parameters"]:
market_id = int(payout["market_id"])
if market_id in campaigns:
campaigns[market_id].reward_per_wk = Decimal(str(payout["bid_budget"])) + \
Decimal(str(payout["ask_budget"]))
campaigns[market_id].spread_max = Decimal(str(payout["spread_max"])) / Decimal("100")
campaigns[market_id].payout_asset = payout["payout_asset"]
return campaigns
async def fetch_trading_pairs(domain="com") -> List[str]:
try:
from hummingbot.connector.exchange.binance.binance_utils import convert_from_exchange_trading_pair
async with aiohttp.ClientSession() as client:
url = EXCHANGE_INFO_URL.format(domain)
async with client.get(url, timeout=10) as response:
if response.status == 200:
data = await response.json()
raw_trading_pairs = [
d["symbol"] for d in data["symbols"]
if d["status"] == "TRADING"
]
trading_pair_list: List[str] = []
for raw_trading_pair in raw_trading_pairs:
converted_trading_pair: Optional[str] = \
convert_from_exchange_trading_pair(raw_trading_pair)
if converted_trading_pair is not None:
trading_pair_list.append(
converted_trading_pair)
return trading_pair_list
except Exception:
# Do nothing if the request fails -- there will be no autocomplete for binance trading pairs
pass
return []
async def get_all_mid_prices(domain="com") -> Optional[Decimal]:
from hummingbot.connector.exchange.binance.binance_utils import convert_from_exchange_trading_pair
async with aiohttp.ClientSession() as client:
url = "https://api.binance.{}/api/v3/ticker/bookTicker".format(domain)
resp = await client.get(url)
resp_json = await resp.json()
ret_val = {}
for record in resp_json:
pair = convert_from_exchange_trading_pair(record["symbol"])
ret_val[pair] = (Decimal(record.get("bidPrice", "0")) + Decimal(record.get("askPrice", "0"))) / Decimal("2")
return ret_val
async def fetch_crypto_com_trading_pairs() -> List[str]:
async with aiohttp.ClientSession() as client:
async with client.get(CRYPTO_COM_ENDPOINT,
timeout=API_CALL_TIMEOUT) as response:
if response.status == 200:
from hummingbot.connector.exchange.crypto_com.crypto_com_utils import \
convert_from_exchange_trading_pair
try:
data: Dict[str, Any] = await response.json()
return [
convert_from_exchange_trading_pair(item["i"])
for item in data["result"]["data"]
]
except Exception:
pass
# Do nothing if the request fails -- there will be no autocomplete for kucoin trading pairs
return []
async def get_all_mid_prices(domain="com") -> Optional[Decimal]:
throttler = BinanceAPIOrderBookDataSource._get_throttler_instance()
async with aiohttp.ClientSession() as client:
async with throttler.execute_task(
limit_id=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL):
url = binance_utils.public_rest_url(
path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL,
domain=domain)
resp = await client.get(url)
resp_json = await resp.json()
ret_val = {}
for record in resp_json:
pair = binance_utils.convert_from_exchange_trading_pair(
record["symbol"])
ret_val[pair] = (
Decimal(record.get("bidPrice", "0")) +
Decimal(record.get("askPrice", "0"))) / Decimal("2")
return ret_val
async def fetch_trading_pairs(domain="com") -> List[str]:
try:
throttler = BinanceAPIOrderBookDataSource._get_throttler_instance()
async with aiohttp.ClientSession() as client:
async with throttler.execute_task(
limit_id=CONSTANTS.EXCHANGE_INFO_PATH_URL):
url = binance_utils.public_rest_url(
path_url=CONSTANTS.EXCHANGE_INFO_PATH_URL,
domain=domain)
async with client.get(url, timeout=10) as response:
if response.status == 200:
data = await response.json()
# fetch d["symbol"] for binance us/com
raw_trading_pairs = [
d["symbol"] for d in data["symbols"]
if d["status"] == "TRADING"
]
trading_pair_targets = [
f"{d['baseAsset']}-{d['quoteAsset']}"
for d in data["symbols"]
if d["status"] == "TRADING"
]
trading_pair_list: List[str] = []
for raw_trading_pair, pair_target in zip(
raw_trading_pairs, trading_pair_targets):
trading_pair: Optional[
str] = binance_utils.convert_from_exchange_trading_pair(
raw_trading_pair)
if trading_pair is not None and trading_pair == pair_target:
trading_pair_list.append(trading_pair)
return trading_pair_list
except Exception:
# Do nothing if the request fails -- there will be no autocomplete for binance trading pairs
pass
return []
def test_parse_three_letters_base_and_four_letters_quote(self):
parsed_pair = utils.convert_from_exchange_trading_pair("BTCUSDT")
self.assertEqual(parsed_pair, "BTC-USDT")
def test_parse_three_letters_base_and_three_letters_quote_matching_with_a_four_letters_quote_candidate(self):
parsed_pair = utils.convert_from_exchange_trading_pair("VETUSD")
self.assertEqual(parsed_pair, "VET-USD")
