Besides rebalancing the accounts, there is no money transfers involved in the long/short strategy. So the transaction latency is not a concern.

The 2% return is net of exchange fees.

A first implementation is work in progress (link here). but hasn't been finished yet.

That would be a possibility yes, but usually a discrepancy between prices tends to last a little bit. So it would be better to wait until you have enough liquidity to match your exposure. For example you don't want Blackbird to trade for $24 when the exposure you set is $5,000. I think it's better to wait until you have enough liquidity to send $5,000 orders.



During the liquidity check, Blackbird reads the order book in depth until it reaches a price that would cover its liquidity needs. So it doesn't just examine the first depth but the following ones as well, if necessary.

As you've probably understood, to stay market neutral the two orders that you send to the exchanges have to be both executed immediately. Since Blackbird sends limit orders (and not market orders because it would be too risky), you have to make sure that the orders can be fully executed at the price you defined. Indeed, if there is not enough liquidity the orders will only be partially executed, and you won't be market neutral anymore.

To prevent that situation, Blackbird makes sure that there is at least 3 times (parameter OrderBookFactor) the liquidity in the order book at the limit price that was defined before executing a trade. So before sending a trade of 2.0 BTC at $500 for example, Blackbird will make sure that there is at least 6.0 BTC at $500 available. Actually it's not exactly $500 but the value defined by the parameter PriceDeltaLimit to give a little bit of margin. But let's ignore that to keep the example simple.

Now, what happens if you don't check the liquidity first? You detect an arbitrage opportunity at $500 (ask price) and you directly send a buy limit order 2.0@$500 to the exchange. But here is the order book of the exchange at that time:

Ask_Price	Size
$500.00	0.5
$502.00	3.2
$503.00	5.4

Your order will be filled for 0.5@$500 and will stay open for the remaining 1.5. If the other order that you send to the other exchange was completely executed, you will have an imbalance: 0.5 BTC vs. 2.0 BTC.

Note: we use 3 times the liquidity because we need some margin in case of slippage: this occurs when the price changes between the time you send the order and the time the exchange processes it.

No, we only check the bid/ask difference between separated exchanges: bid on exchange A vs. ask on exchange B, ask on exchange A vs. bid on exchange B. We don't need to look at the bid/ask spread within an exchange to do arbitrage.



This is exactly what Blackbird does. Once the spread threshold SpreadEntry is reached the system will buy at the ask and sell at the bid. This is called crossing the spread and helps ensuring an immediate execution.



I know Selenium a little bit and I don't think speed would be an issue as the tasks can be executed at a pretty fast pace. I'm sure that it might be possible to implement, but could be rather complex (credentials, order generation, waiting until the order is 100% filled, verification, etc) and not as robust as the REST calls we are using now. But technically yes I think it's definitely possible.

I don't think I understand the question. Can you elaborate?

Yes that's correct. Since we want to be hedged against the market, the two orders (long and short) need to be executed as fast as possible. If we need a USD/CNY conversion before it will also have to be exectued as fast as possible. As you mentioned there is no money or bitcoin transfer in this project so the hours needed to confirm a transaction don't apply here.

Thanks. Yes this is something we've already considered (see previous posts on this thread). Adding this extra layer of currency conversion (e.g. USD/CNY) would generate more inefficiencies that can be captured as arbitrage opportunities. We will need to add the real-time currency rate into the spread calculation and the currency risk will need to be hedged.

Hi netmonk, thanks.

The structure of the code should allows programmers to (relatively) easily add new exchanges and new cryptocurrencies. Basically you "just" need to change the API calls from BTC to ETH. For example, the bid/ask information call on Bitfinex would change from:

https://api.bitfinex.com/v1/ticker/btcusd

to:

https://api.bitfinex.com/v1/ticker/ethbtc

And yes, at least one exchange needs to offer short selling on ETH and be implemented in Blackbird to do BTC/ETH arbitrage.

Warning: if you do BTC/ETH arbitrage you will be hedged against the market risk on ETH but not on BTC anymore. USD/BTC and USD/ETH would be safer, unless you are willing to accept BTC risk.

I have the same problem as you. This is due to the BitLicense license issued by the NY State Department of Financial Services.

Bitfinex decided to avoid having to comply to that license by imposing limitations to NY residents: we can no longer hold BTC on our accounts, among other things. More info here on their FAQ.

Fortunately, I opened an account on Bitfinex before the license so I can still margin trade to test Blackbird.

Yes thanks, Poloniex sounds indeed promising as their API covers short selling with marginBuy and marginSell.

Unfortunately, I am not authorized to open an account on Poloniex since I live in New York. But I already created the generic files poloniex.h and poloniex.cpp if anyone wants to implement the functions.

For the moment, only Bitfinex offers an API to short sell. We hope that 796.com will offer a similar API soon.

Thanks. The potential loss while using short selling is indeed infinite ...in theory. In reality, if your loss gets close to a defined amount of your account, you will get a margin call from the exchange. So you will never lose more than what you have on your margin account: if you only deposited $20 and you don't want to meet the margin calls then $20 will be your maximum loss.

That being said, Blackbird sends the two long and short orders at the same time. But if one is fully executed and not the other one (i.e. the market moved away from one order) then yes you won't be market neutral, that's correct. A solution would be to divide every order into child orders, e.g. a $50,000 order becomes 500 * $100 child orders. When you send your child orders you make sure than the number of already filled long orders is similar to the number of already filled short orders until all the orders are sent and fully filled. So the long/short unbalance would be $100 maximum at any time. That would be a nice implementation for Blackbird.

Meanwhile, note that to make sure the orders are almost instantly fully executed we do the following:

• we always cross the spread
• before we send an order we make sure that there is at least 3 times (by default) the liquidity in the order book than what we need for that order.

Again, you will get a margin call from the exchange if your potential loss is above the limit. If you don't meet the margin call then the exchange will close your BTC position, usually at market price, and their loss will be covered by your margin account. So yes, you could entirely lose your margin account, but not more.

Note that as for now, Blackbird doesn't deal with margin calls.

No BTC-e is not yet implemented. From the README file:

The following exchange should be implemented soon:

• BTC-e

I will post something here when the implementation is done.

Fingers crossed their API will allow short selling. We would double the arbitrage opportunities!

Thanks mxnsch and siameze!

Hopefully it will be possible to programmatically short sell on 796.com. For the moment, we still only have Bitfinex that offers that feature.

PS: the Chinese New Year is next Monday (February 8^th).

A first implementation of 796.com has been done (link to cpp file here) but has never been tested. The getLimitPrice() function has to be rewritten to match the other exchanges.

Note that 796.com only trade Bitcoin futures contracts.

Hi enigma969, thank you for your interest.


Yes, if you want to maximize your exposure you should put $1,500 on Bitfinex and $1,500 on one of the other supported exchanges. But please first test with a small amount of money!



I don't have any specific recommendation. I personally use a laptop for programming and troubleshooting and a Google Cloud server (Compute Engine Micro) to run Blackbird 24/7.
The CPU and memory consumptions are usually low (C++ helps here) but you need a correct Internet connection.



Yes this is probably due to the latency of your Internet connection. See a workaround here (issue #39).

I though the best way (and easiest way) was to create one log file per execution. Since Blackbird is supposed to run many days in a row, the size of a single log file can end up being hundreds of MB.



It might be an issue with Kraken. I just uploaded a new version on GitHub that will give more details about the issue. Also, could you please open an issue on the issue page and we can continue from there? Thanks.



Yes that's correct, but not in seconds. DebugMaxIteration represents the number of market analysis loops. So Blackbird will run for approximately {DebugMaxIteration * GapSec} seconds.

Yes this is the expected behavior. We decided to output everything to a log file rather than the console.

FYI, to avoid any confusion I just hardcoded the exchanges that can short sell and the ones that can't. As of today, only Bitfinex can short sell.

Thanks