Пример #1
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        suffix = "/v2/trading/placeOrder"
        payload = {
            "instrument": "{}-{}".format(coin, cur),
            "side": dir,
            "volume": amount,
            "price": price
        }
        headers = self.create_signature_headers(suffix)
        req = Request(base_url, suffix)
        rsl = req.post(headers, payload)
        order_id = rsl["id"]
        time.sleep(10)
        cancelled = self.cancel_order(order_id)
        return cancelled
Пример #2
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        suffix = "/exchange/{}limit".format(dir)
        data = {
            "currencyPair": "{}/{}".format(coin, cur),
            "price": price,
            "quantity": amount
        }
        req = Request(base_url, suffix)
        headers = self.create_signature_headers(suffix, data)
        rsl = req.post(headers, data)
        if rsl["success"] == True:
            return True
        return False
Пример #3
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        suffix = "/v1/Trade/OrderSubmit"    
        nonce = str(int(time.time() * 1000))
        data = {
            "nonce": nonce,
            "market": "{}_{}".format(coin, cur),
            "orderType": "Limit",
            "type": dir,
            "amount": amount,
            "price": price,
        }
        headers = self.create_signature_headers({"data": data})
        req = Request(base_url, suffix)
        rsl = req.post(headers, data)
        order_id = rsl["orderId"]
        if not order_id: return False
        return self.cancel_order(order_id)
Пример #4
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        endpoint = "/v2/auth/w/order/submit"
        if dir == "sell":
            amount = float(amount) * -1

        data = {
            "type": "IOC",
            "symbol": "t{}{}".format(coin, cur),
            "price": price,
            "amount": amount
        }
        headers = self.create_signature_headers(endpoint, data)
        req = Request(api_auth_url, endpoint)
        rsl = req.post(headers, data)
        if len(rsl) >= 7:
            return rsl[7]
        logging.info(rsl)
        return rsl[2]
Пример #5
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        suffix = "/api/spot/v3/orders"
        data = {
            "type": "limit",
            "side": dir,
            "instrument_id": "{}-{}".format(coin, cur),
            "size": amount,
            "price": price,
            "order_type": 3
        }
        headers = self.create_signature_headers(suffix, data)
        req = Request(base_url, suffix)
        rsl = req.post(headers, data)
        if rsl["result"] == True:
            return True
        return False
Пример #6
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        suffix = "/v1/order/ioc?"
        nonce = str(int(time.time() * 1000))
        payload = {
            "access_id": self.key,
            "tonce": nonce,
            "market": cur + coin,
            "type": dir,
            "amount": amount,
            "price": price
        }
        query_str = urlencode(payload)
        headers = self.create_signature_headers(query_str)
        req = Request(base_url, suffix + query_str)
        rsl = req.post(headers, payload)
        if rsl["message"] == "ok":
            return True
        return False
Пример #7
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        endpoint = "/api/{}/{}_{}".format(dir, cur, coin)
        payload = {
            "amount": amount,
            "price": price,
            "ioc_order": True
        }
        headers = self.create_signature_headers(endpoint, payload)
        req = Request(base_url, endpoint)
        rsl = req.post(headers, payload)
        if "error" in rsl.keys():
            logging.error(rsl)
        logging.info(rsl)
        return rsl
Пример #8
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        suffix = "/api/v1/orders"
        headers = self.create_signature_headers(suffix)
        data = {
            "side": dir,
            "symbol": "{}-{}".format(coin, cur),
            "price": price,
            "size": amount,
            "timeInForce": "IOC"
        }
        req = Request(base_url, suffix)
        rsl = req.post(headers, data)
        if "orderId" in rsl.keys():
            return True
        return False
Пример #9
0
 def get_balances(self):
     """Get Balances from exchange. Only exchange account is supported."""
     endpoint = "/v2/auth/r/wallets"
     headers = self.create_signature_headers(endpoint)
     req = Request(api_auth_url, endpoint)
     rsl = req.post(headers)
     balances = []
     for e in rsl:
         if e[0] == "exchange":
             balances.append({
                 "coin": e[1].upper(),
                 "balance": e[2]
             })
     return balances
Пример #10
0
 def get_balances(self):
     """Get Balances from exchange"""
     endpoint = "/api/v2/balance/"
     headers = create_signature_headers(endpoint, "")
     req = Request(base_url, endpoint)
     rsl = req.post(headers)
     balances = []
     for entry in rsl:
         if "balance" in entry.split("_")[1]:
             balances.append({
                 "coin": entry.split("_")[0].upper(),
                 "balance": rsl[entry]
             })
     return balances
Пример #11
0
 def cancel_order(order_id):
     suffix = "/v1/Trade/OrderCancel"
     nonce = str(int(time.time() * 1000))
     data = {
         "nonce": nonce,
         "market": "{}_{}".format(coin, cur),
         "cancelType": "Trade",
         "orderId": order_id
     }
     headers = self.create_signature_headers({"data": data})
     req = Request(base_url, endpoint)
     rsl = req.post(headers, data)
     if "error" in rsl.keys():
         return False
     return True
Пример #12
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        endpoint = "/api/v1/order/new"
        symbol = "{}_{}".format(coin, cur)
        data = {
            "market": symbol,
            "side": dir,
            "amount": amount,
            "price": price,
            "request": endpoint,
            "nonce": str(int(time.time() * 1000))
        }
        headers = self.create_signature_headers(data)
        req = Request(base_url, endpoint)
        rsl = req.post(headers, data)
        if rsl["success"] == True:
            order_id = rsl["result"]["orderId"]
            time.sleep(5)
            if self.cancel_order(order_id, symbol):
                return True
        logging.error("Error canceling order {} in {}".format(
                rsl, __name__.upper()
            ))
        return False
Пример #13
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create order. Only spot account supported.

            :param cur
                Currency to use to create the order.
            :param coin
                Coin to use to create the order.
            :param amount
                Amount to use to create the order. 
                TODO Should check if within user balance else use user balance.
            :param price
                Not used, kept for compatibility with other wrappers.
            :param dir
                Direction of the order. Needs to be one of "buy" or "sell".
        """
        if dir.lower() not in ["buy", "sell"]:
            return None
        if None in [cur, coin, amount]:
            return None
        endpoint = "/api/v3/order"
        symbol = coin + cur
        query = {
            "side": dir.upper(),
            "symbol": symbol.upper(),
            "timestamp": int(time.time() * 1000),
            "type": "MARKET",
            "quantity": float(amount)
        }
        headers = {"X-MBX-APIKEY": self.key}
        signature = self.create_signature(query)
        query["signature"] = signature
        req = Request(base_url, endpoint)
        try:
            rsl = req.post(headers, query)
            logging.error(rsl)
            return rsl
        except Exception as e:
            logging.error("Error {} in {}".format(e, __name__.upper()))
            return e
Пример #14
0
 def get_balances(self):
     # FIXME not working but why??
     """Get Balances from exchange"""
     nonce = int(time.time() * 1000)
     endpoint = "/api/v1/fund/allAccount"
     query = "{}?accessKey={}&nonce={}".format(endpoint, self.key, nonce)
     signature = self.create_signature(query)
     query_signed = "{}&signData={}".format(query, signature)
     req = Request(base_url, query_signed)
     rsl = req.post(headers=None)
     balances = []
     for i in rsl:
         if isinstance(i, dict):
             logging.info(i)
             balances.append({
                 "coin": i["currency"].upper(),
                 "balance": i["fix"]
             })
     if len(balances) > 0:
         return balances
     else:
         return rsl
Пример #15
0
    def create_order(self, cur, coin, amount, price, dir):
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """
        endpoint = "/api/v3/orders.json?"
        nonce = str(int(time.time() * 1000))
        data = {
            "access_key": self.key,
            "tonce": nonce,
            "market": coin.lower() + cur.lower(),
            "price": price,
            "side": dir,
            "volume": amount,
            "order_type": "IOC"
        }
        query = urlencode(data)
        signature = self.create_signature("POST", endpoint, query)
        query_signed = "{}&signature={}".format(query, signature)
        data["signature"] = signature
        req = Request(base_url, endpoint)
        rsl = req.post(headers=None, data=data)
        if "error" in rsl.keys():
            logging.error("Error passing order in {}".format(__name__.upper()))
        return rsl
Пример #16
0
    def create_order(self, cur, coin, amount, price, dir):
        # FIXME returns invalid signData.
        """
            Create a trade order.
            In bitfinex direction is indicated by amount being positive or negative.

            :param cur
                Currency to user to create the trade order.
            :param coin
                Coin to use to create the trade order.
            :param amount
                Amount to be used to create the order. If the direction equal "buy"
                amount is positive, else if direction equals "sell"
                amount is negative or multiplied by -1.
            :param price
                Price to use to create the trade order.
            :param dir
                Unused paramenter, kept for compatibility.
        """

        if dir == "buy":
            dir = 1
        elif dir == "sell":
            dir = 2
        symbol = "coin-{}-{}".format(cur.lower(), coin.lower())
        nonce = int(time.time()) * 1000
        endpoint = "/api/v1/trade/placeOrder"
        query = "{}?accessKey={}&amount={}&price={}&symbol={}&tradeType={}&nonce={}".format(
            endpoint, self.key, amount, price, symbol, dir, nonce)
        logging.info(query)
        signature = self.create_signature(query)
        query_signed = "{}&signData={}".format(query, signature)
        req = Request(base_url, query_signed)
        rsl = req.post(headers=None)
        if rsl["success"] == True:
            time.sleep(5)
            self.cancel_order(rsl, symbol)
        return rsl["message"]
Пример #17
0
    def cancel_order(self, order_id, symbol):
        """
            Cancel given order.

            :param order_id
                Id of the order to be cancelled.
            :param symbol
                Market symbol where to cancel the order.
        """
        endpoint = "/api/v1/order/cancel"
        data = {
            "market": symbol,
            "orderId": order_id,
            "request": endpoint,
            "nonce": str(int(time.time() * 1000))
        }
        headers = self.create_signature_headers(data)
        req = Request(base_url, endpoint)
        rsl = req.post(headers, data)
        if rsl["success"] == False:
            logging.error("Error canceling order {} in {}".format(
                rsl, __name__.upper()
            ))
        return rsl
Пример #18
0
    def cancel_order(self, order_id, symbol):
        """ 
            Cancel order.

            :param order_id
                Order id to be cancelled.
            :param cur
                Cur to use in market selection.
            :param coin
                Coin to use in market selection.
        """
        nonce = int(time.time()) * 1000
        endpoint = "/api/v1/trade/cancelOrder"
        query = "{}?accessKey={}&orderId={}&symbol={}&nonce={}".format(
            endpoint, self.key, order_id, symbol, nonce)
        signature = self.create_signature(query)
        query_signed = query + "&signData={}".format(signature)
        req = Request(base_url, query_signed)
        rsl = req.post(headers=None)
        if "error" in rsl.keys():
            logging.error("Error {} in {}".format(rsl.__dict__,
                                                  __name__.upper()))
            return rsl
        return rsl
Пример #19
0
 def get_book(cls, symbol):
     endpoint = "/returnOrderBook"
     data = {"market": symbol, "count": 1}
     req = Request(base_url, endpoint)
     rsl = req.post(None, data)
     return rsl
Пример #20
0
 def get_balances(self):
     """Get Balances from exchange"""
     endpoint = "/returnCompleteBalances"
     req = Request(base_url, endpoint)
     rsl = req.post(None, {"address": self.key})
     return Normalizer(rsl).normalize_balances()