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