Calculate the maximum order amount

[oliver-zehentleitner]

I have tried to come up with a way to calculate the maximum order amount for a market order for Binance USDⓈ-M futures. This is the amount that is displayed here in the web interface:

There are different scenarios, depending on fees:

• Fees are paid with USDT: In that case, the fees influence the calculation of the max. amount.
• Fees are paid with BNB: The fees are not part of the max. amount calculation.

Here is what Binance tells us about calculating the cost required to open a position, from which you can calculate the max. amount: Link to documentation page

From this information, I have come up with a function that calculates the max. amount for a given available balance. However my function has limitations:

• It only works when fees are paid with BNB, not with USDT (on the testnet, fees are always paid with USDT, so I can't use it there, that's a serious limitation for me)
• It only works for market orders.
• If there currently is an open position, the max. amount is only correct for increasing the size of this position. That means for example, if you are in a long position already, the max. amount is correct for "buy" but the max. amount for "sell" is wrong.

The max. amount is correct for buy and sell if there currently is no open position.

So how can we improve this calculation to fix the limitations? The web interface probably shows the max. amount as the result of calculations that are being done in JavaScript in the browser. Could somebody reverse-engineer the JavaScript and code it in Python?

Here is my code:

import math

def max_order_amt(available_balance, bid_price, ask_price, mark_price, leverage, direction):

    if direction == 'LONG':
        assuming_price = ask_price * (1 + 0.0005)

        if mark_price - assuming_price >= 0:
            max_amt = (available_balance * leverage) / \
                      (assuming_price * -1 * leverage + assuming_price + mark_price * leverage)
        else:
            max_amt = (available_balance * leverage) / \
                      (assuming_price - mark_price * leverage + assuming_price * leverage)

    elif direction == 'SHORT':
        max_amt = available_balance * leverage / max(bid_price, mark_price)

    return math.floor(max_amt * 1000) / 1000

On thing that I should be doing, but have not done anywhere yet: Use the Python decimal module. Binance is using decimal floating point arithmetic, while Python by default is using binary floating point arithmetic. This leads to many little problems that I am kind of ignoring by round()ing, but it's not a clean solution.

by @MikeMaxNow