def get_timestamp(self):
"""
:return: timestamp in seconds
"""
if not request.public_request(self.url, "/v2/exchange/timestamp"):
return
return int(request.public_request(self.url, "/v2/exchange/timestamp")["timestamp"])/1000
def load_balances(self):
"""
Load all balances from the exchange and updates them in the tokens
:return: balances
"""
if self.get_key_pair() is None:
log.log("log.txt", "No Pair Loaded")
return []
params = {
"addresses": neo_get_scripthash_from_private_key(self.key_pair.PrivateKey),
"contract_hashes": self.get_contract("NEO").get_latest_hash()
}
raw_balances = request.public_request(self.get_url(), "/v2/balances", params)
if not raw_balances:
log.log("log.txt", "No balance Pair")
return
for token in self.tokens:
token.set_balance(0)
for name in raw_balances["confirmed"]:
token = self.get_token(name)
token.set_balance(int(float(raw_balances["confirmed"][name])))
#log.log("log.txt", "%s=%d" % (name,int(float(raw_balances["confirmed"][name]))))
return raw_balances
def load_pairs(self, bases=None):
"""
Load all pairs from exchange(with bases)
:param bases: i.e. NEO, SWTH, ...
:return: List of objects
"""
params = None
if bases:
params = {"bases": bases}
raw_pairs = request.public_request(self.url, "/v2/exchange/pairs", params)
if not raw_pairs:
log.log("log.txt", "Error loading Pairs - no data")
return
self.pairs = []
i = 0
for val in raw_pairs:
quote, base = val.split("_")
quote_token = self.get_token(quote)
base_token = self.get_token(base)
if not quote_token or not base_token:
continue
self.pairs.append(Pair(self, quote_token, base_token))
log.log("log.txt", "%s loaded" % (val))
i = i + 1
log.log("log.txt", "%d Pairs loaded" % (i))
return self.pairs
def load_24_hours(self):
"""
Load 24h candlestick for each pair
:return: list of objects
"""
raw_candles = request.public_request(self.get_url(),
"/v2/tickers/last_24_hours")
if not raw_candles:
return
candlesticks = []
timestamp = time.time() - 1 * 60 * 60 * 24
for token in self.tokens:
token.set_volume(0)
for entry in raw_candles:
pair = self.get_pair(entry["pair"])
if not pair:
continue
candlestick = Candlestick(pair, timestamp, float(entry["open"]),
float(entry["close"]),
float(entry["high"]),
float(entry["low"]),
float(entry["volume"]),
float(entry["quote_volume"]),
Candlestick.INTERVAL_MIN_1440)
candlesticks.append(candlestick)
pair.set_candlestick_24h(candlestick)
pair.get_base_token().add_volume(candlestick.get_base_volume())
pair.get_quote_token().add_volume(candlestick.get_quote_volume())
return candlesticks
def load_offers(self):
"""
Load offers and create new order book.
:param contract: contract
:return: list of offers
"""
if self.is_updating():
return False
if self.is_blocked():
return False
if self.is_not_outdated():
return False
self.set_updating(True)
params = {"pair": self.get_symbol()}
raw_offers = request.public_request(self.exchange.get_url(),
"/v2/offers/book", params)
self.last_update = time.time()
if not raw_offers:
return self.set_updating(False)
self.asks = []
for offer in raw_offers["asks"]:
self.asks.append(Offer(offer["price"], offer["quantity"]))
self.bids = []
for offer in raw_offers["bids"]:
self.bids.append(Offer(offer["price"], offer["quantity"]))
log.log("pair.txt", "%s: updated" % self.get_symbol())
self.set_updating(False)
def load_orders(self, pair=None):
"""
Load all orders
:param pair: orders from pair
:return: orders
"""
pair_name = ""
if pair:
pair_name = pair.get_symbol()
params = {
"address":
neo_get_scripthash_from_private_key(self.key_pair.PrivateKey),
"contract_hash":
self.get_contract("NEO").get_latest_hash(),
"pair":
pair_name
}
orders = request.public_request(self.get_url(), "/v2/orders", params)
if not orders:
return
trades = []
for order_details in orders:
trades = trades + self.order_to_trades(order_details)
return trades
def load_last_price(self):
"""
Load last price of pairs
:return: last price
"""
self.last_price = float(
request.public_request(self.exchange.get_url(),
"/v2/tickers/last_price",
{self.get_quote_token().get_name()}))
return self.last_price
def load_offers(self, contract=None):
"""
Load offers and create new order book.
:param contract: contract
:return: list of offers
"""
if self.is_updating():
return False
if self.is_blocked():
return False
self.set_updating(True)
if contract is None:
contract = self.get_exchange().get_contract("NEO")
params = {
"blockchain": contract.get_blockchain().lower(),
"pair": self.get_symbol(),
"contract_hash": contract.get_latest_hash()
}
raw_offers = request.public_request(self.exchange.get_url(),
"/v2/offers", params)
if not raw_offers:
return self.set_updating(False)
self.offers = []
for offer in raw_offers:
way = Trade.WAY_BUY
quote_amount = offer["want_amount"]
base_amount = offer["offer_amount"]
if offer["offer_asset"] == self.get_quote_token().get_name():
way = Trade.WAY_SELL
quote_amount = offer["offer_amount"]
base_amount = offer["want_amount"]
price = base_amount / quote_amount * pow(
10,
self.get_quote_token().get_decimals() -
self.get_base_token().get_decimals())
if offer["available_amount"] < offer["offer_amount"]:
quote_amount = int(offer["available_amount"] /
offer["offer_amount"] * quote_amount)
base_amount = int(offer["available_amount"] /
offer["offer_amount"] * base_amount)
self.offers.append(Offer(way, quote_amount, base_amount, price))
self.orderbook = OrderBook(self, self.offers)
self.orderbook.set_timestamp(time.time())
log.log("pair.txt", "%s: updated" % self.get_symbol())
self.fire_on_update()
self.set_updating(False)
return self.offers
def load_contracts(self):
"""
Load contracts and creates objects
:return: list of objects
"""
raw_contracts = request.public_request(self.url,
"/v2/exchange/contracts")
if not raw_contracts:
return
self.contracts = []
for key in raw_contracts:
self.contracts.append(Contract(key, raw_contracts[key]))
return self.contracts
def load_tokens(self):
"""
Load all tokens from exchange and create objects
:return: list of tokens
"""
raw_tokens = request.public_request(self.url, "/v2/exchange/tokens")
if not raw_tokens:
return
self.tokens = []
for key in raw_tokens:
self.tokens.append(
Token(key, raw_tokens[key]["decimals"],
raw_tokens[key]["hash"]))
return self.tokens
def load_last_prices(self):
"""
Load price of each pair
:return: list of prices
"""
prices = request.public_request(self.get_url(), "/v2/tickers/last_price")
if not prices:
return
for quote in prices:
for base in prices[quote]:
pair = self.get_pair(quote+"_"+base)
if not pair:
continue
pair.set_last_price(float(prices[quote][base]))
return prices
def load_contracts(self):
"""
Load contracts and creates objects
:return: list of objects
"""
raw_contracts = request.public_request(self.url, "/v2/exchange/contracts")
if not raw_contracts:
log.log("log.txt", "Error loading Contract - no data")
return
self.contracts = []
i=0
for key in raw_contracts:
self.contracts.append(Contract(key, raw_contracts[key]))
i=i+1
log.log("log.txt", "%d contracts loaded" % (i))
return self.contracts
def load_tokens(self):
"""
Load all tokens from exchange and create objects
:return: list of tokens
"""
raw_tokens = request.public_request(self.url, "/v2/exchange/tokens")
if not raw_tokens:
log.log("log.txt", "Error loading Token - no data")
return
self.tokens = []
i = 0
for key in raw_tokens:
if raw_tokens[key]["trading_active"]:
self.tokens.append(Token(key, raw_tokens[key]["decimals"], raw_tokens[key]["hash"], raw_tokens[key]["minimum_quantity"]))
log.log("log.txt", "%s loaded - minimum is %s" % (key,raw_tokens[key]["minimum_quantity"]))
i = i + 1
else:
log.log("log.txt", "%s not loaded" % (key))
log.log("log.txt", "%d tokens loaded" % (i))
return self.tokens
def load_pairs(self, bases=None):
"""
Load all pairs from exchange(with bases)
:param bases: i.e. NEO, SWTH, ...
:return: List of objects
"""
params = None
if bases:
params = {"bases": bases}
raw_pairs = request.public_request(self.url, "/v2/exchange/pairs",
params)
if not raw_pairs:
return
self.pairs = []
for val in raw_pairs:
quote, base = val.split("_")
quote_token = self.get_token(quote)
base_token = self.get_token(base)
if not quote_token or not base_token:
continue
self.pairs.append(Pair(self, quote_token, base_token))
return self.pairs
def load_tickers(self, start_time, end_time, interval):
"""
Load candlesticks of requested interval
:param start_time: start time
:param end_time: end time
:param interval: interval
:return: list of candlesticks
"""
params = {
"start_time": start_time,
"end_time": end_time,
"interval": interval
}
raw_candles = request.public_request(self.exchange.get_url(),
"/v2/tickers/candlesticks",
params)
self.candlesticks = []
for entry in raw_candles:
self.candlesticks.append(
Candlestick(self, int(entry["time"]), float(entry["open"]),
float(entry["close"]), float(entry["high"]),
float(entry["low"]), float(entry["volume"]),
float(entry["quote_volume"]), interval))
return self.candlesticks
