From db7bb461a1341d045b5c21f44f6ed60f4de7be9b Mon Sep 17 00:00:00 2001 From: Rodrigo <95635797+poly-rodr@users.noreply.github.com> Date: Tue, 14 Jan 2025 19:20:07 -0300 Subject: [PATCH 1/2] FOK sell orders --- .../{market_order.py => market_buy_order.py} | 4 +- examples/market_sell_order.py | 36 + py_clob_client/client.py | 4 +- py_clob_client/clob_types.py | 8 +- py_clob_client/order_builder/builder.py | 52 +- setup.py | 2 +- tests/order_builder/test_builder.py | 713 +++++++++++++++++- 7 files changed, 770 insertions(+), 49 deletions(-) rename examples/{market_order.py => market_buy_order.py} (90%) create mode 100644 examples/market_sell_order.py diff --git a/examples/market_order.py b/examples/market_buy_order.py similarity index 90% rename from examples/market_order.py rename to examples/market_buy_order.py index e677859..e8a22d7 100644 --- a/examples/market_order.py +++ b/examples/market_buy_order.py @@ -4,6 +4,7 @@ from py_clob_client.clob_types import ApiCreds, MarketOrderArgs, OrderType from dotenv import load_dotenv from py_clob_client.constants import AMOY +from py_clob_client.order_builder.constants import BUY load_dotenv() @@ -23,7 +24,8 @@ def main(): # create a market buy order for the equivalent of 100 USDC at the market price order_args = MarketOrderArgs( token_id="71321045679252212594626385532706912750332728571942532289631379312455583992563", - amount=100, + amount=100, # $$$ + side=BUY, ) signed_order = client.create_market_order(order_args) resp = client.post_order(signed_order, orderType=OrderType.FOK) diff --git a/examples/market_sell_order.py b/examples/market_sell_order.py new file mode 100644 index 0000000..618b821 --- /dev/null +++ b/examples/market_sell_order.py @@ -0,0 +1,36 @@ +import os + +from py_clob_client.client import ClobClient +from py_clob_client.clob_types import ApiCreds, MarketOrderArgs, OrderType +from dotenv import load_dotenv +from py_clob_client.constants import AMOY +from py_clob_client.order_builder.constants import SELL + + +load_dotenv() + + +def main(): + host = "http://localhost:8080" + key = os.getenv("PK") + creds = ApiCreds( + api_key=os.getenv("CLOB_API_KEY"), + api_secret=os.getenv("CLOB_SECRET"), + api_passphrase=os.getenv("CLOB_PASS_PHRASE"), + ) + chain_id = AMOY + client = ClobClient(host, key=key, chain_id=chain_id, creds=creds) + + # create a market buy order for the equivalent of 100 USDC at the market price + order_args = MarketOrderArgs( + token_id="71321045679252212594626385532706912750332728571942532289631379312455583992563", + amount=100, # SHARES + side=SELL, + ) + signed_order = client.create_market_order(order_args) + resp = client.post_order(signed_order, orderType=OrderType.FOK) + print(resp) + print("Done!") + + +main() diff --git a/py_clob_client/client.py b/py_clob_client/client.py index a63958f..50b381e 100644 --- a/py_clob_client/client.py +++ b/py_clob_client/client.py @@ -728,8 +728,8 @@ def calculate_market_price(self, token_id: str, side: str, amount: float) -> flo if side == "BUY": if book.asks is None: raise Exception("no match") - return self.builder.calculate_market_price(book.asks, amount) + return self.builder.calculate_buy_market_price(book.asks, amount) else: if book.bids is None: raise Exception("no match") - return self.builder.calculate_market_price(book.bids, amount) + return self.builder.calculate_sell_market_price(book.bids, amount) diff --git a/py_clob_client/clob_types.py b/py_clob_client/clob_types.py index 058d77e..753d1af 100644 --- a/py_clob_client/clob_types.py +++ b/py_clob_client/clob_types.py @@ -78,7 +78,13 @@ class MarketOrderArgs: amount: float """ - Amount in terms of Collateral + BUY orders: $$$ Amount to buy + SELL orders: Shares to sell + """ + + side: str + """ + Side of the order """ price: float = 0 diff --git a/py_clob_client/order_builder/builder.py b/py_clob_client/order_builder/builder.py index 84a99cb..c967f0a 100644 --- a/py_clob_client/order_builder/builder.py +++ b/py_clob_client/order_builder/builder.py @@ -82,21 +82,38 @@ def get_order_amounts( raise ValueError(f"order_args.side must be '{BUY}' or '{SELL}'") def get_market_order_amounts( - self, amount: float, price: float, round_config: RoundConfig + self, side: str, amount: float, price: float, round_config: RoundConfig ): - raw_maker_amt = round_down(amount, round_config.size) raw_price = round_normal(price, round_config.price) - raw_taker_amt = raw_maker_amt / raw_price - if decimal_places(raw_taker_amt) > round_config.amount: - raw_taker_amt = round_up(raw_taker_amt, round_config.amount + 4) + if side == BUY: + raw_maker_amt = round_down(amount, round_config.size) + raw_taker_amt = raw_maker_amt / raw_price if decimal_places(raw_taker_amt) > round_config.amount: - raw_taker_amt = round_down(raw_taker_amt, round_config.amount) + raw_taker_amt = round_up(raw_taker_amt, round_config.amount + 4) + if decimal_places(raw_taker_amt) > round_config.amount: + raw_taker_amt = round_down(raw_taker_amt, round_config.amount) + + maker_amount = to_token_decimals(raw_maker_amt) + taker_amount = to_token_decimals(raw_taker_amt) + + return UtilsBuy, maker_amount, taker_amount - maker_amount = to_token_decimals(raw_maker_amt) - taker_amount = to_token_decimals(raw_taker_amt) + elif side == SELL: + raw_maker_amt = round_down(amount, round_config.size) - return maker_amount, taker_amount + raw_taker_amt = raw_maker_amt * raw_price + if decimal_places(raw_taker_amt) > round_config.amount: + raw_taker_amt = round_up(raw_taker_amt, round_config.amount + 4) + if decimal_places(raw_taker_amt) > round_config.amount: + raw_taker_amt = round_down(raw_taker_amt, round_config.amount) + + maker_amount = to_token_decimals(raw_maker_amt) + taker_amount = to_token_decimals(raw_taker_amt) + + return UtilsSell, maker_amount, taker_amount + else: + raise ValueError(f"order_args.side must be '{BUY}' or '{SELL}'") def create_order( self, order_args: OrderArgs, options: CreateOrderOptions @@ -143,7 +160,8 @@ def create_market_order( """ Creates and signs a market order """ - maker_amount, taker_amount = self.get_market_order_amounts( + side, maker_amount, taker_amount = self.get_market_order_amounts( + order_args.side, order_args.amount, order_args.price, ROUNDING_CONFIG[options.tick_size], @@ -155,7 +173,7 @@ def create_market_order( tokenId=order_args.token_id, makerAmount=str(maker_amount), takerAmount=str(taker_amount), - side=UtilsBuy, + side=side, feeRateBps=str(order_args.fee_rate_bps), nonce=str(order_args.nonce), signer=self.signer.address(), @@ -175,7 +193,7 @@ def create_market_order( return order_builder.build_signed_order(data) - def calculate_market_price( + def calculate_buy_market_price( self, positions: list[OrderSummary], amount_to_match: float ) -> float: sum = 0 @@ -184,3 +202,13 @@ def calculate_market_price( if sum >= amount_to_match: return float(p.price) raise Exception("no match") + + def calculate_sell_market_price( + self, positions: list[OrderSummary], amount_to_match: float + ) -> float: + sum = 0 + for p in reversed(positions): + sum += float(p.size) + if sum >= amount_to_match: + return float(p.price) + raise Exception("no match") diff --git a/setup.py b/setup.py index fe9ab30..b6a952e 100644 --- a/setup.py +++ b/setup.py @@ -5,7 +5,7 @@ setuptools.setup( name="py_clob_client", - version="0.18.0", + version="0.20.0", author="Polymarket Engineering", author_email="engineering@polymarket.com", maintainer="Polymarket Engineering", diff --git a/tests/order_builder/test_builder.py b/tests/order_builder/test_builder.py index 3659614..277c09c 100644 --- a/tests/order_builder/test_builder.py +++ b/tests/order_builder/test_builder.py @@ -12,7 +12,12 @@ from py_clob_client.signer import Signer from py_clob_client.order_builder.builder import OrderBuilder, ROUNDING_CONFIG from py_clob_client.order_builder.helpers import decimal_places, round_normal -from py_order_utils.model import POLY_GNOSIS_SAFE, EOA +from py_order_utils.model import ( + POLY_GNOSIS_SAFE, + EOA, + BUY as UtilsBuy, + SELL as UtilsSell, +) # publicly known private key private_key = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" @@ -21,11 +26,11 @@ class TestOrderBuilder(TestCase): - def test_calculate_market_price_buy(self): + def test_calculate_buy_market_price(self): # empty with self.assertRaises(Exception): builder = OrderBuilder(signer) - builder.calculate_market_price([], 100) + builder.calculate_buy_market_price([], 100) # not enough with self.assertRaises(Exception): @@ -34,7 +39,7 @@ def test_calculate_market_price_buy(self): OrderSummary(price="0.4", size="100"), ] builder = OrderBuilder(signer) - builder.calculate_market_price(positions, 100) + builder.calculate_buy_market_price(positions, 100) # OK positions = [ @@ -43,7 +48,7 @@ def test_calculate_market_price_buy(self): OrderSummary(price="0.3", size="100"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.3) + self.assertEqual(builder.calculate_buy_market_price(positions, 100), 0.3) positions = [ OrderSummary(price="0.5", size="100"), @@ -51,7 +56,7 @@ def test_calculate_market_price_buy(self): OrderSummary(price="0.3", size="100"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.4) + self.assertEqual(builder.calculate_buy_market_price(positions, 100), 0.4) positions = [ OrderSummary(price="0.5", size="120"), @@ -59,7 +64,7 @@ def test_calculate_market_price_buy(self): OrderSummary(price="0.3", size="100"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.4) + self.assertEqual(builder.calculate_buy_market_price(positions, 100), 0.4) positions = [ OrderSummary(price="0.5", size="200"), @@ -67,22 +72,22 @@ def test_calculate_market_price_buy(self): OrderSummary(price="0.3", size="100"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.5) + self.assertEqual(builder.calculate_buy_market_price(positions, 100), 0.5) - def test_calculate_market_price_sell(self): + def test_calculate_sell_market_price(self): # empty with self.assertRaises(Exception): builder = OrderBuilder(signer) - builder.calculate_market_price([], 100) + builder.calculate_sell_market_price([], 100) # not enough with self.assertRaises(Exception): positions = [ - OrderSummary(price="0.4", size="100"), - OrderSummary(price="0.5", size="100"), + OrderSummary(price="0.4", size="10"), + OrderSummary(price="0.5", size="10"), ] builder = OrderBuilder(signer) - builder.calculate_market_price(positions, 100) + builder.calculate_sell_market_price(positions, 100) # OK positions = [ @@ -91,23 +96,23 @@ def test_calculate_market_price_sell(self): OrderSummary(price="0.5", size="100"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.5) + self.assertEqual(builder.calculate_sell_market_price(positions, 100), 0.5) positions = [ OrderSummary(price="0.3", size="100"), OrderSummary(price="0.4", size="300"), - OrderSummary(price="0.5", size="100"), + OrderSummary(price="0.5", size="10"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.4) + self.assertEqual(builder.calculate_sell_market_price(positions, 100), 0.4) positions = [ OrderSummary(price="0.3", size="100"), OrderSummary(price="0.4", size="200"), - OrderSummary(price="0.5", size="100"), + OrderSummary(price="0.5", size="10"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.4) + self.assertEqual(builder.calculate_sell_market_price(positions, 100), 0.4) positions = [ OrderSummary(price="0.3", size="300"), @@ -115,7 +120,7 @@ def test_calculate_market_price_sell(self): OrderSummary(price="0.5", size="100"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.4) + self.assertEqual(builder.calculate_sell_market_price(positions, 200), 0.4) positions = [ OrderSummary(price="0.3", size="334"), @@ -123,9 +128,9 @@ def test_calculate_market_price_sell(self): OrderSummary(price="0.5", size="100"), ] builder = OrderBuilder(signer) - self.assertEqual(builder.calculate_market_price(positions, 100), 0.3) + self.assertEqual(builder.calculate_sell_market_price(positions, 300), 0.3) - def test_get_market_order_amounts_0_1(self): + def test_get_market_order_amounts_buy_0_1(self): builder = OrderBuilder(signer) delta_price = 0.1 @@ -134,9 +139,10 @@ def test_get_market_order_amounts_0_1(self): while amount <= 1000: price = 0.1 while price <= 1: - maker, taker = builder.get_market_order_amounts( - amount, price, ROUNDING_CONFIG["0.1"] + side, maker, taker = builder.get_market_order_amounts( + BUY, amount, price, ROUNDING_CONFIG["0.1"] ) + self.assertEqual(side, UtilsBuy) self.assertEqual(decimal_places(maker), 0) self.assertEqual(decimal_places(taker), 0) self.assertGreaterEqual( @@ -146,7 +152,7 @@ def test_get_market_order_amounts_0_1(self): amount = amount + delta_size - def test_get_market_order_amounts_0_01(self): + def test_get_market_order_amounts_buy_0_01(self): builder = OrderBuilder(signer) delta_price = 0.01 @@ -155,9 +161,10 @@ def test_get_market_order_amounts_0_01(self): while amount <= 100: price = 0.01 while price <= 1: - maker, taker = builder.get_market_order_amounts( - amount, price, ROUNDING_CONFIG["0.01"] + side, maker, taker = builder.get_market_order_amounts( + BUY, amount, price, ROUNDING_CONFIG["0.01"] ) + self.assertEqual(side, UtilsBuy) self.assertEqual(decimal_places(maker), 0) self.assertEqual(decimal_places(taker), 0) self.assertGreaterEqual( @@ -167,7 +174,7 @@ def test_get_market_order_amounts_0_01(self): amount = amount + delta_size - def test_get_market_order_amounts_0_001(self): + def test_get_market_order_amounts_buy_0_001(self): builder = OrderBuilder(signer) delta_price = 0.001 @@ -176,9 +183,10 @@ def test_get_market_order_amounts_0_001(self): while amount <= 10: price = 0.001 while price <= 1: - maker, taker = builder.get_market_order_amounts( - amount, price, ROUNDING_CONFIG["0.001"] + side, maker, taker = builder.get_market_order_amounts( + BUY, amount, price, ROUNDING_CONFIG["0.001"] ) + self.assertEqual(side, UtilsBuy) self.assertEqual(decimal_places(maker), 0) self.assertEqual(decimal_places(taker), 0) self.assertGreaterEqual( @@ -188,7 +196,7 @@ def test_get_market_order_amounts_0_001(self): amount = amount + delta_size - def test_get_market_order_amounts_0_0001(self): + def test_get_market_order_amounts_buy_0_0001(self): builder = OrderBuilder(signer) delta_price = 0.0001 @@ -197,9 +205,10 @@ def test_get_market_order_amounts_0_0001(self): while amount <= 1: price = 0.0001 while price <= 1: - maker, taker = builder.get_market_order_amounts( - amount, price, ROUNDING_CONFIG["0.0001"] + side, maker, taker = builder.get_market_order_amounts( + BUY, amount, price, ROUNDING_CONFIG["0.0001"] ) + self.assertEqual(side, UtilsBuy) self.assertEqual(decimal_places(maker), 0) self.assertEqual(decimal_places(taker), 0) self.assertGreaterEqual( @@ -209,6 +218,94 @@ def test_get_market_order_amounts_0_0001(self): amount = amount + delta_size + def test_get_market_order_amounts_sell_0_1(self): + builder = OrderBuilder(signer) + + delta_price = 0.1 + delta_size = 0.01 + amount = 0.01 + while amount <= 1000: + price = 0.1 + while price <= 1: + side, maker, taker = builder.get_market_order_amounts( + SELL, amount, price, ROUNDING_CONFIG["0.1"] + ) + self.assertEqual(side, UtilsSell) + self.assertEqual(decimal_places(maker), 0) + self.assertEqual(decimal_places(taker), 0) + self.assertGreaterEqual( + round_normal(maker / taker, 2), round_normal(price, 2) + ) + price = price + delta_price + + amount = amount + delta_size + + def test_get_market_order_amounts_sell_0_01(self): + builder = OrderBuilder(signer) + + delta_price = 0.01 + delta_size = 0.01 + amount = 0.01 + while amount <= 100: + price = 0.01 + while price <= 1: + side, maker, taker = builder.get_market_order_amounts( + SELL, amount, price, ROUNDING_CONFIG["0.01"] + ) + self.assertEqual(side, UtilsSell) + self.assertEqual(decimal_places(maker), 0) + self.assertEqual(decimal_places(taker), 0) + self.assertGreaterEqual( + round_normal(maker / taker, 4), round_normal(price, 4) + ) + price = price + delta_price + + amount = amount + delta_size + + def test_get_market_order_amounts_sell_0_001(self): + builder = OrderBuilder(signer) + + delta_price = 0.001 + delta_size = 0.01 + amount = 0.01 + while amount <= 10: + price = 0.001 + while price <= 1: + side, maker, taker = builder.get_market_order_amounts( + SELL, amount, price, ROUNDING_CONFIG["0.001"] + ) + self.assertEqual(side, UtilsSell) + self.assertEqual(decimal_places(maker), 0) + self.assertEqual(decimal_places(taker), 0) + self.assertGreaterEqual( + round_normal(maker / taker, 6), round_normal(price, 6) + ) + price = price + delta_price + + amount = amount + delta_size + + def test_get_market_order_amounts_sell_0_0001(self): + builder = OrderBuilder(signer) + + delta_price = 0.0001 + delta_size = 0.01 + amount = 0.01 + while amount <= 1: + price = 0.0001 + while price <= 1: + side, maker, taker = builder.get_market_order_amounts( + SELL, amount, price, ROUNDING_CONFIG["0.0001"] + ) + self.assertEqual(side, UtilsSell) + self.assertEqual(decimal_places(maker), 0) + self.assertEqual(decimal_places(taker), 0) + self.assertGreaterEqual( + round_normal(taker / maker, 8), round_normal(price, 8) + ) + price = price + delta_price + + amount = amount + delta_size + def test_get_order_amounts_buy_0_1(self): builder = OrderBuilder(signer) @@ -2120,6 +2217,7 @@ def test_create_market_order_buy_0_1(self): signed_order = builder.create_market_order( order_args=MarketOrderArgs( + side=BUY, token_id="123", price=0.5, amount=100, @@ -2187,6 +2285,7 @@ def test_create_market_order_buy_0_01(self): signed_order = builder.create_market_order( order_args=MarketOrderArgs( + side=BUY, token_id="123", price=0.56, amount=100, @@ -2254,6 +2353,7 @@ def test_create_market_order_buy_0_001(self): signed_order = builder.create_market_order( order_args=MarketOrderArgs( + side=BUY, token_id="123", price=0.056, amount=100, @@ -2321,6 +2421,7 @@ def test_create_market_order_buy_0_0001(self): signed_order = builder.create_market_order( order_args=MarketOrderArgs( + side=BUY, token_id="123", price=0.0056, amount=100, @@ -2388,6 +2489,7 @@ def test_create_market_order_buy_0_1_neg_risk(self): signed_order = builder.create_market_order( order_args=MarketOrderArgs( + side=BUY, token_id="123", price=0.5, amount=100, @@ -2455,6 +2557,7 @@ def test_create_market_order_buy_0_01_neg_risk(self): signed_order = builder.create_market_order( order_args=MarketOrderArgs( + side=BUY, token_id="123", price=0.56, amount=100, @@ -2522,6 +2625,7 @@ def test_create_market_order_buy_0_001_neg_risk(self): signed_order = builder.create_market_order( order_args=MarketOrderArgs( + side=BUY, token_id="123", price=0.056, amount=100, @@ -2589,6 +2693,7 @@ def test_create_market_order_buy_0_0001_neg_risk(self): signed_order = builder.create_market_order( order_args=MarketOrderArgs( + side=BUY, token_id="123", price=0.0056, amount=100, @@ -2650,3 +2755,547 @@ def test_create_market_order_buy_0_0001_neg_risk(self): / float(signed_order.order["takerAmount"]), 0.0056, ) + + def test_create_market_order_sell_0_1(self): + builder = OrderBuilder(signer) + + signed_order = builder.create_market_order( + order_args=MarketOrderArgs( + side=SELL, + token_id="123", + price=0.5, + amount=100, + fee_rate_bps=111, + nonce=123, + ), + options=CreateOrderOptions(tick_size="0.1", neg_risk=False), + ) + + self.assertTrue(isinstance(signed_order.order["salt"], int)) + self.assertIsNotNone(signed_order) + self.assertEqual( + signed_order.order["maker"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["signer"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["taker"], + "0x0000000000000000000000000000000000000000", + ) + self.assertEqual( + signed_order.order["tokenId"], + 123, + ) + self.assertEqual( + signed_order.order["makerAmount"], + 100000000, + ) + self.assertEqual( + signed_order.order["takerAmount"], + 50000000, + ) + self.assertEqual( + signed_order.order["side"], + 1, + ) + self.assertEqual( + signed_order.order["expiration"], + 0, + ) + self.assertEqual( + signed_order.order["nonce"], + 123, + ) + self.assertEqual( + signed_order.order["feeRateBps"], + 111, + ) + self.assertEqual( + signed_order.order["signatureType"], + EOA, + ) + self.assertIsNotNone(signed_order.signature) + self.assertGreaterEqual( + float(signed_order.order["takerAmount"]) + / float(signed_order.order["makerAmount"]), + 0.5, + ) + + def test_create_market_order_sell_0_01(self): + builder = OrderBuilder(signer) + + signed_order = builder.create_market_order( + order_args=MarketOrderArgs( + side=SELL, + token_id="123", + price=0.56, + amount=100, + fee_rate_bps=111, + nonce=123, + ), + options=CreateOrderOptions(tick_size="0.01", neg_risk=False), + ) + + self.assertTrue(isinstance(signed_order.order["salt"], int)) + self.assertIsNotNone(signed_order) + self.assertEqual( + signed_order.order["maker"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["signer"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["taker"], + "0x0000000000000000000000000000000000000000", + ) + self.assertEqual( + signed_order.order["tokenId"], + 123, + ) + self.assertEqual( + signed_order.order["makerAmount"], + 100000000, + ) + self.assertEqual( + signed_order.order["takerAmount"], + 56000000, + ) + self.assertEqual( + signed_order.order["side"], + 1, + ) + self.assertEqual( + signed_order.order["expiration"], + 0, + ) + self.assertEqual( + signed_order.order["nonce"], + 123, + ) + self.assertEqual( + signed_order.order["feeRateBps"], + 111, + ) + self.assertEqual( + signed_order.order["signatureType"], + EOA, + ) + self.assertIsNotNone(signed_order.signature) + self.assertGreaterEqual( + float(signed_order.order["takerAmount"]) + / float(signed_order.order["makerAmount"]), + 0.56, + ) + + def test_create_market_order_sell_0_001(self): + builder = OrderBuilder(signer) + + signed_order = builder.create_market_order( + order_args=MarketOrderArgs( + side=SELL, + token_id="123", + price=0.056, + amount=100, + fee_rate_bps=111, + nonce=123, + ), + options=CreateOrderOptions(tick_size="0.001", neg_risk=False), + ) + + self.assertTrue(isinstance(signed_order.order["salt"], int)) + self.assertIsNotNone(signed_order) + self.assertEqual( + signed_order.order["maker"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["signer"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["taker"], + "0x0000000000000000000000000000000000000000", + ) + self.assertEqual( + signed_order.order["tokenId"], + 123, + ) + self.assertEqual( + signed_order.order["makerAmount"], + 100000000, + ) + self.assertEqual( + signed_order.order["takerAmount"], + 5600000, + ) + self.assertEqual( + signed_order.order["side"], + 1, + ) + self.assertEqual( + signed_order.order["expiration"], + 0, + ) + self.assertEqual( + signed_order.order["nonce"], + 123, + ) + self.assertEqual( + signed_order.order["feeRateBps"], + 111, + ) + self.assertEqual( + signed_order.order["signatureType"], + EOA, + ) + self.assertIsNotNone(signed_order.signature) + self.assertGreaterEqual( + float(signed_order.order["takerAmount"]) + / float(signed_order.order["makerAmount"]), + 0.056, + ) + + def test_create_market_order_sell_0_0001(self): + builder = OrderBuilder(signer) + + signed_order = builder.create_market_order( + order_args=MarketOrderArgs( + side=SELL, + token_id="123", + price=0.0056, + amount=100, + fee_rate_bps=111, + nonce=123, + ), + options=CreateOrderOptions(tick_size="0.0001", neg_risk=False), + ) + + self.assertTrue(isinstance(signed_order.order["salt"], int)) + self.assertIsNotNone(signed_order) + self.assertEqual( + signed_order.order["maker"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["signer"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["taker"], + "0x0000000000000000000000000000000000000000", + ) + self.assertEqual( + signed_order.order["tokenId"], + 123, + ) + self.assertEqual( + signed_order.order["makerAmount"], + 100000000, + ) + self.assertEqual( + signed_order.order["takerAmount"], + 560000, + ) + self.assertEqual( + signed_order.order["side"], + 1, + ) + self.assertEqual( + signed_order.order["expiration"], + 0, + ) + self.assertEqual( + signed_order.order["nonce"], + 123, + ) + self.assertEqual( + signed_order.order["feeRateBps"], + 111, + ) + self.assertEqual( + signed_order.order["signatureType"], + EOA, + ) + self.assertIsNotNone(signed_order.signature) + self.assertGreaterEqual( + float(signed_order.order["takerAmount"]) + / float(signed_order.order["makerAmount"]), + 0.0056, + ) + + def test_create_market_order_sell_0_1_neg_risk(self): + builder = OrderBuilder(signer) + + signed_order = builder.create_market_order( + order_args=MarketOrderArgs( + side=SELL, + token_id="123", + price=0.5, + amount=100, + fee_rate_bps=111, + nonce=123, + ), + options=CreateOrderOptions(tick_size="0.1", neg_risk=True), + ) + + self.assertTrue(isinstance(signed_order.order["salt"], int)) + self.assertIsNotNone(signed_order) + self.assertEqual( + signed_order.order["maker"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["signer"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["taker"], + "0x0000000000000000000000000000000000000000", + ) + self.assertEqual( + signed_order.order["tokenId"], + 123, + ) + self.assertEqual( + signed_order.order["makerAmount"], + 100000000, + ) + self.assertEqual( + signed_order.order["takerAmount"], + 50000000, + ) + self.assertEqual( + signed_order.order["side"], + 1, + ) + self.assertEqual( + signed_order.order["expiration"], + 0, + ) + self.assertEqual( + signed_order.order["nonce"], + 123, + ) + self.assertEqual( + signed_order.order["feeRateBps"], + 111, + ) + self.assertEqual( + signed_order.order["signatureType"], + EOA, + ) + self.assertIsNotNone(signed_order.signature) + self.assertGreaterEqual( + float(signed_order.order["takerAmount"]) + / float(signed_order.order["makerAmount"]), + 0.5, + ) + + def test_create_market_order_sell_0_01_neg_risk(self): + builder = OrderBuilder(signer) + + signed_order = builder.create_market_order( + order_args=MarketOrderArgs( + side=SELL, + token_id="123", + price=0.56, + amount=100, + fee_rate_bps=111, + nonce=123, + ), + options=CreateOrderOptions(tick_size="0.01", neg_risk=True), + ) + + self.assertTrue(isinstance(signed_order.order["salt"], int)) + self.assertIsNotNone(signed_order) + self.assertEqual( + signed_order.order["maker"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["signer"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["taker"], + "0x0000000000000000000000000000000000000000", + ) + self.assertEqual( + signed_order.order["tokenId"], + 123, + ) + self.assertEqual( + signed_order.order["makerAmount"], + 100000000, + ) + self.assertEqual( + signed_order.order["takerAmount"], + 56000000, + ) + self.assertEqual( + signed_order.order["side"], + 1, + ) + self.assertEqual( + signed_order.order["expiration"], + 0, + ) + self.assertEqual( + signed_order.order["nonce"], + 123, + ) + self.assertEqual( + signed_order.order["feeRateBps"], + 111, + ) + self.assertEqual( + signed_order.order["signatureType"], + EOA, + ) + self.assertIsNotNone(signed_order.signature) + self.assertGreaterEqual( + float(signed_order.order["takerAmount"]) + / float(signed_order.order["makerAmount"]), + 0.56, + ) + + def test_create_market_order_sell_0_001_neg_risk(self): + builder = OrderBuilder(signer) + + signed_order = builder.create_market_order( + order_args=MarketOrderArgs( + side=SELL, + token_id="123", + price=0.056, + amount=100, + fee_rate_bps=111, + nonce=123, + ), + options=CreateOrderOptions(tick_size="0.001", neg_risk=True), + ) + + self.assertTrue(isinstance(signed_order.order["salt"], int)) + self.assertIsNotNone(signed_order) + self.assertEqual( + signed_order.order["maker"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["signer"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["taker"], + "0x0000000000000000000000000000000000000000", + ) + self.assertEqual( + signed_order.order["tokenId"], + 123, + ) + self.assertEqual( + signed_order.order["makerAmount"], + 100000000, + ) + self.assertEqual( + signed_order.order["takerAmount"], + 5600000, + ) + self.assertEqual( + signed_order.order["side"], + 1, + ) + self.assertEqual( + signed_order.order["expiration"], + 0, + ) + self.assertEqual( + signed_order.order["nonce"], + 123, + ) + self.assertEqual( + signed_order.order["feeRateBps"], + 111, + ) + self.assertEqual( + signed_order.order["signatureType"], + EOA, + ) + self.assertIsNotNone(signed_order.signature) + self.assertGreaterEqual( + float(signed_order.order["takerAmount"]) + / float(signed_order.order["makerAmount"]), + 0.056, + ) + + def test_create_market_order_sell_0_0001_neg_risk(self): + builder = OrderBuilder(signer) + + signed_order = builder.create_market_order( + order_args=MarketOrderArgs( + side=SELL, + token_id="123", + price=0.0056, + amount=100, + fee_rate_bps=111, + nonce=123, + ), + options=CreateOrderOptions(tick_size="0.0001", neg_risk=True), + ) + + self.assertTrue(isinstance(signed_order.order["salt"], int)) + self.assertIsNotNone(signed_order) + self.assertEqual( + signed_order.order["maker"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["signer"], + "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", + ) + self.assertEqual( + signed_order.order["taker"], + "0x0000000000000000000000000000000000000000", + ) + self.assertEqual( + signed_order.order["tokenId"], + 123, + ) + self.assertEqual( + signed_order.order["makerAmount"], + 100000000, + ) + self.assertEqual( + signed_order.order["takerAmount"], + 560000, + ) + self.assertEqual( + signed_order.order["side"], + 1, + ) + self.assertEqual( + signed_order.order["expiration"], + 0, + ) + self.assertEqual( + signed_order.order["nonce"], + 123, + ) + self.assertEqual( + signed_order.order["feeRateBps"], + 111, + ) + self.assertEqual( + signed_order.order["signatureType"], + EOA, + ) + self.assertIsNotNone(signed_order.signature) + self.assertGreaterEqual( + float(signed_order.order["takerAmount"]) + / float(signed_order.order["makerAmount"]), + 0.0056, + ) From c2cd00ee6e81a817b60c96284f8865d5d8f5e05e Mon Sep 17 00:00:00 2001 From: Rodrigo <95635797+poly-rodr@users.noreply.github.com> Date: Tue, 14 Jan 2025 19:36:49 -0300 Subject: [PATCH 2/2] fix --- py_clob_client/client.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/py_clob_client/client.py b/py_clob_client/client.py index 50b381e..b5f5a4a 100644 --- a/py_clob_client/client.py +++ b/py_clob_client/client.py @@ -379,7 +379,7 @@ def create_market_order( if order_args.price is None or order_args.price <= 0: order_args.price = self.calculate_market_price( - order_args.token_id, "BUY", order_args.amount + order_args.token_id, order_args.side, order_args.amount ) if not price_valid(order_args.price, tick_size):