agorise/bsips
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

bsip35: add definition of smaller order

Browse source
This commit is contained in:
abitmore 2018-02-22 14:35:23 +00:00
parent 58e11a7397
commit 259fbe05ac
1 changed files with 32 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
bsip-0035.md
View file

@ -155,7 +155,38 @@ filled at a less favorable price. It's the least bad compromise since it has
the most efficiency (highest traded volume while not hard to implement) among the most efficiency (highest traded volume while not hard to implement) among
the solutions. the solutions.
However, when filling a small order at a less favorable price, the receiving The algorithm can be described as follows (sample code is
[here](https://github.com/bitshares/bitshares-core/blob/2.0.171105a/libraries/chain/db_market.cpp#L311-L324)):
Assuming the maker order is selling amount `X` of asset A, with price
`maker_price = maker_b_amount / maker_a_amount`; assuming the taker is buying
asset A with amount `Y` of asset B, with price
`taker_price = taker_b_amount / taker_a_amount`. Anyway, since the two orders
will be matched at maker price, the taker price doesn't matter here as long
as it's higher than or equal to maker price. Note: currently all limit orders
are implemented as sell limit orders, so in the example, the taker order can
only specify amount of asset B but not amount of asset A.
Now compare `X * maker_price` with `Y`. To be accurate (avoid rounding),
compare `X' = X * maker_b_amount` with `Y' = Y * maker_a_amount`.
* The best scenario is when `X' == Y'`, which means both orders can be
completely filled at `maker_price`.
* If `X' < Y'`, it means the maker order can be completely filled but the
taker order can't, aka the maker order is smaller.
In this case, maker pay amount `X` of asset A to taker, taker pay amount
`Y" = round_down( X' / maker_a_amount )` of asset B to maker.
Note: after rounded down, `Y"` may be smaller than the rational number
`X * maker_price`, which means `Y" / X` may be lower than `maker_price`,
that said, the maker order may has been filled at a less favorable price.
* If `X' > Y'`, it means the taker order can be completely filled but the
maker order can't, aka the taker order is smaller.
In this case, taker pay amount `Y` of asset B to maker, maker pay amount
`X" = round_down( Y' / maker_b_amount )` of asset A to taker.
Note: after rounded down, `X"` may be smaller than the rational number
`Y / taker_price`, which means `Y / X"` may be higher than `taker_price`,
that said, the taker order may has been filled at a less favorable price.
When filling a small order at a less favorable price, the receiving
amount is often rounded down to zero, thus causes the something-for-nothing amount is often rounded down to zero, thus causes the something-for-nothing
issue. Current code tried to solve the issue by cancelling the smaller order issue. Current code tried to solve the issue by cancelling the smaller order
when it would receive nothing, but only applied this rule in a few senarios when it would receive nothing, but only applied this rule in a few senarios