diff --git a/.gitignore b/.gitignore index 3acf817..521cae7 100644 --- a/.gitignore +++ b/.gitignore @@ -130,3 +130,5 @@ dmypy.json .pyre/ test_state.json .vscode/ + +myenv \ No newline at end of file diff --git a/README.md b/README.md index 5dd7361..4ea795f 100644 --- a/README.md +++ b/README.md @@ -56,10 +56,10 @@ Context manager: from bxsolana import provider async with provider.http() as api: - print(await api.get_orderbook(market="ETHUSDT")) + print(await api.get_raydium_pools()) async with provider.ws() as api: - async for update in api.get_orderbooks_stream(market="ETHUSDT"): + async for update in api.get_prices_stream(projects=[api.Project.P_RAYDIUM], tokens=["So11111111111111111111111111111111111111112"]): print(update) ``` @@ -74,7 +74,7 @@ p = provider.grpc() api = await bxsolana.trader_api(p) try: - await api.get_orderbook(market="ETHUSDT") + await api.get_jupiter_prices(tokens=["So11111111111111111111111111111111111111112", "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"]) finally: await p.close() ``` diff --git a/bxsolana/examples/__init__.py b/bxsolana/examples/__init__.py index 6d6d0a0..b030e45 100644 --- a/bxsolana/examples/__init__.py +++ b/bxsolana/examples/__init__.py @@ -1,5 +1,4 @@ from .request_utils import do_requests -from .transaction_request_utils import do_transaction_requests from .stream_utils import do_stream from .constants import ( PUBLIC_KEY, @@ -8,21 +7,11 @@ ORDER_ID, MARKET, ) -from .order_utils import ( - cancel_order, - cancel_all_orders, - replace_order_by_client_order_id, -) -from .order_lifecycle import order_lifecycle __all__ = [ "do_requests", "do_transaction_requests", "do_stream", - "cancel_all_orders", - "cancel_order", - "replace_order_by_client_order_id", - "order_lifecycle", "PUBLIC_KEY", "USDC_WALLET", "OPEN_ORDERS", diff --git a/bxsolana/examples/order_lifecycle.py b/bxsolana/examples/order_lifecycle.py deleted file mode 100644 index 2be1b67..0000000 --- a/bxsolana/examples/order_lifecycle.py +++ /dev/null @@ -1,97 +0,0 @@ -import asyncio -import async_timeout # type: ignore - -from bxsolana import provider -from bxsolana_trader_proto import api as proto -from .order_utils import cancel_order, place_order, settle_funds - -crank_timeout = 60 - - -async def order_lifecycle( - p1: provider.Provider, - p2: provider.Provider, - owner_addr, - payer_addr, - market_addr, - order_side, - order_type, - order_amount, - order_price, - open_orders_addr, - base_token_wallet, - quote_token_wallet, -): - print("order lifecycle test\n") - - oss = p2.get_order_status_stream( - get_order_status_stream_request=proto.GetOrderStatusStreamRequest( - market=market_addr, owner_address=owner_addr - ) - ) - - # pyre-ignore[6]: - task = asyncio.create_task(oss.__anext__()) - await asyncio.sleep(10) - - # Place Order => `Open` - client_order_id = await place_order( - p1, - owner_addr, - payer_addr, - market_addr, - order_side, - order_type, - order_amount, - order_price, - open_orders_addr, - ) - try: - print(f"waiting {crank_timeout}s for place order to be cranked") - async with async_timeout.timeout(crank_timeout): - response = await task - if response.order_info.order_status == proto.OrderStatus.OS_OPEN: - print("order went to orderbook (`OPEN`) successfully") - else: - print( - "order should be `OPEN` but is " - + response.order_info.order_status.__str__() # noqa: W503 - ) - except asyncio.TimeoutError: - raise Exception("no updates after placing order") - print() - - await asyncio.sleep(10) - - # Cancel Order => `Cancelled` - await cancel_order( - p1, client_order_id, market_addr, owner_addr, open_orders_addr - ) - try: - print(f"waiting {crank_timeout}s for cancel order to be cranked") - async with async_timeout.timeout(crank_timeout): - response = await oss.__anext__() - if ( - response.order_info.order_status - == proto.OrderStatus.OS_CANCELLED # noqa: W503 - ): - print("order cancelled (`CANCELLED`) successfully") - else: - print( - "order should be `CANCELLED` but is " - + response.order_info.order_status.__str__() # noqa: W503 - ) - except asyncio.TimeoutError: - raise Exception("no updates after cancelling order") - print() - - # Settle Funds - await settle_funds( - p1, - owner_addr, - market_addr, - base_token_wallet, - quote_token_wallet, - open_orders_addr, - ) - print() diff --git a/bxsolana/examples/order_utils.py b/bxsolana/examples/order_utils.py deleted file mode 100644 index 6852a95..0000000 --- a/bxsolana/examples/order_utils.py +++ /dev/null @@ -1,329 +0,0 @@ -import random -import time - -from bxsolana_trader_proto import api as proto - -from bxsolana import provider -from bxsolana.transaction import signing - -crank_timeout = 60 - - -async def place_order( - p: provider.Provider, - owner_addr, - payer_addr, - market_addr, - order_side, - order_type, - order_amount, - order_price, - open_orders_addr, -) -> int: - print("starting place order") - - client_order_id = random.randint(0, 1000000) - post_order_response = await p.post_order( - post_order_request=proto.PostOrderRequest( - owner_address=owner_addr, - payer_address=payer_addr, - market=market_addr, - side=order_side, - type=[order_type], - amount=order_amount, - price=order_price, - open_orders_address=open_orders_addr, - client_order_id=client_order_id, - ) - ) - print("place order transaction created successfully") - - signed_tx = signing.sign_tx(post_order_response.transaction.content) - - post_submit_response = await p.post_submit( - post_submit_request=proto.PostSubmitRequest( - transaction=proto.TransactionMessage(content=signed_tx), - skip_pre_flight=True, - ) - ) - - print( - f"placing order with clientOrderID {client_order_id.__str__()}, " - f" response signature: {post_submit_response.signature}" - ) - - return client_order_id - - -async def place_order_with_tip( - p: provider.Provider, - owner_addr, - payer_addr, - market_addr, - order_side, - order_type, - order_amount, - order_price, - open_orders_addr, -) -> int: - print("starting place order") - - client_order_id = random.randint(0, 1000000) - post_order_response = await p.post_order( - post_order_request=proto.PostOrderRequest( - owner_address=owner_addr, - payer_address=payer_addr, - market=market_addr, - side=order_side, - type=[order_type], - amount=order_amount, - price=order_price, - open_orders_address=open_orders_addr, - client_order_id=client_order_id, - tip=1030, - ) - ) - print("place order transaction created successfully") - - signed_tx = signing.sign_tx(post_order_response.transaction.content) - - post_submit_response = await p.post_submit( - post_submit_request=proto.PostSubmitRequest( - transaction=proto.TransactionMessage(content=signed_tx), - skip_pre_flight=True, - front_running_protection=True, - use_staked_rp_cs=True, - ) - ) - - print( - f"placing order with clientOrderID {client_order_id.__str__()}, " - f" response signature: {post_submit_response.signature}" - ) - - return client_order_id - - -async def cancel_order( - p: provider.Provider, - client_order_id: int, - market_addr: str, - owner_addr: str, - open_orders_addr: str, -): - print("starting cancel order") - - cancel_order_response = await p.post_cancel_by_client_order_id( - post_cancel_by_client_order_id_request=proto.PostCancelByClientOrderIdRequest( - client_order_id=client_order_id, - market_address=market_addr, - owner_address=owner_addr, - open_orders_address=open_orders_addr, - ) - ) - print("cancel order transaction created successfully") - - signed_tx = signing.sign_tx(cancel_order_response.transaction.content) - - post_submit_response = await p.post_submit( - post_submit_request=proto.PostSubmitRequest( - transaction=proto.TransactionMessage(content=signed_tx), - skip_pre_flight=True, - ) - ) - print( - f"cancelling order with clientOrderID {client_order_id.__str__()}, " - f" response signature: {post_submit_response.signature}" - ) - - -async def settle_funds( - p: provider.Provider, - owner_addr: str, - market_addr: str, - base_token_wallet: str, - quote_token_wallet: str, - open_orders_addr: str, -): - print("starting settle funds") - - post_settle_response = await p.post_settle( - post_settle_request=proto.PostSettleRequest( - owner_address=owner_addr, - market=market_addr, - base_token_wallet=base_token_wallet, - quote_token_wallet=quote_token_wallet, - open_orders_address=open_orders_addr, - ) - ) - print("settle transaction created successfully") - - signed_settle_tx = signing.sign_tx(post_settle_response.transaction.content) - - post_submit_response = await p.post_submit( - post_submit_request=proto.PostSubmitRequest( - transaction=proto.TransactionMessage(content=signed_settle_tx), - skip_pre_flight=True, - ) - ) - - print( - "settling funds, response signature: " + post_submit_response.signature - ) - - -async def cancel_all_orders( - p: provider.Provider, - owner_addr, - payer_addr, - order_side, - order_type, - order_amount, - order_price, - open_orders_addr, - market_addr, -): - print("cancel all test\n") - - print("placing order #1") - client_order_id_1 = await place_order( - p, - owner_addr, - payer_addr, - market_addr, - order_side, - order_type, - order_amount, - order_price, - open_orders_addr, - ) - print() - - print("placing order #2") - client_order_id_2 = await place_order( - p, - owner_addr, - payer_addr, - market_addr, - order_side, - order_type, - order_amount, - order_price, - open_orders_addr, - ) - print() - - print(f"waiting {crank_timeout}s for place orders to be cranked") - time.sleep(crank_timeout) - - o = await p.get_open_orders( - get_open_orders_request=proto.GetOpenOrdersRequest( - market=market_addr, address=owner_addr - ) - ) - found1 = False - found2 = False - - for order in o.orders: - if order.client_order_id == str(client_order_id_1): - found1 = True - elif order.client_order_id == str(client_order_id_2): - found2 = True - - if not found1 or not found2: - raise Exception("one/both orders not found in orderbook") - print("2 orders placed successfully\n") - - await cancel_all(p, owner_addr, open_orders_addr, market_addr) - - print(f"\nwaiting {crank_timeout}s for cancel order(s) to be cranked") - time.sleep(crank_timeout) - - o = await p.get_open_orders( - get_open_orders_request=proto.GetOpenOrdersRequest( - market=market_addr, address=owner_addr - ) - ) - if len(o.orders) != 0: - print(f"{len(o.orders)} orders in orderbook not cancelled") - else: - print("orders in orderbook cancelled") - print() - - -async def cancel_all( - p: provider.Provider, owner_addr, open_orders_addr, market_addr -): - print("starting cancel all") - - open_orders_addresses = [""] - if open_orders_addresses is None: - open_orders_addresses.append(open_orders_addr) - - cancel_all_response = await p.post_cancel_all( - post_cancel_all_request=proto.PostCancelAllRequest( - market=market_addr, - owner_address=owner_addr, - open_orders_addresses=open_orders_addresses, - ) - ) - print("cancel all transaction created successfully") - - signatures = [] - for transaction in cancel_all_response.transactions: - signed_tx = signing.sign_tx(transaction.content) - post_submit_response = await p.post_submit( - post_submit_request=proto.PostSubmitRequest( - transaction=proto.TransactionMessage(content=signed_tx), - skip_pre_flight=True, - ) - ) - signatures.append(post_submit_response.signature) - - signatures_string = ", ".join(signatures) - print(f"cancelling all orders, response signature(s): {signatures_string}") - - -async def replace_order_by_client_order_id( - p: provider.Provider, - owner_addr, - payer_addr, - market_addr, - order_side, - order_type, - order_amount, - order_price, - open_orders_addr, -) -> int: - print("starting replace order by client order ID") - - client_order_id = random.randint(0, 1000000) - post_order_response = await p.post_replace_by_client_order_id( - post_order_request=proto.PostOrderRequest( - owner_address=owner_addr, - payer_address=payer_addr, - market=market_addr, - side=order_side, - type=[order_type], - amount=order_amount, - price=order_price, - open_orders_address=open_orders_addr, - client_order_id=client_order_id, - ) - ) - print("replace order transaction created successfully") - - signed_tx = signing.sign_tx(post_order_response.transaction.content) - - post_submit_response = await p.post_submit( - post_submit_request=proto.PostSubmitRequest( - transaction=proto.TransactionMessage(content=signed_tx), - skip_pre_flight=True, - ) - ) - print( - f"replacing order with clientOrderID {client_order_id.__str__()}, " - f" response signature: {post_submit_response.signature}" - ) - - return client_order_id diff --git a/bxsolana/examples/request_utils.py b/bxsolana/examples/request_utils.py index 61b07f8..40e7ce2 100644 --- a/bxsolana/examples/request_utils.py +++ b/bxsolana/examples/request_utils.py @@ -66,17 +66,6 @@ async def do_requests( ).to_json() ) - print("fetching market depth") - print( - ( - await api.get_market_depth_v2( - get_market_depth_request_v2=proto.GetMarketDepthRequestV2( - limit=1, market="SOLUSDC" - ) - ) - ).to_json() - ) - print("fetching priority fee") print( ( @@ -102,49 +91,7 @@ async def do_requests( ).to_json() ) - # markets API - print("fetching all markets") - print( - ( - await api.get_markets_v2( - get_markets_request_v2=proto.GetMarketsRequestV2() - ) - ).to_json() - ) - - print("fetching SOL/USDC orderbook") - print( - ( - await api.get_orderbook_v2( - get_orderbook_request_v2=proto.GetOrderbookRequestV2( - market="SOLUSDC" - ) - ) - ).to_json() - ) - - print("fetching SOL/USDC ticker") - print( - ( - await api.get_tickers_v2( - get_tickers_request_v2=proto.GetTickersRequestV2( - market="SOLUSDC" - ) - ) - ).to_json() - ) - - print("fetching all tickers") - print( - ( - await api.get_tickers_v2( - get_tickers_request_v2=proto.GetTickersRequestV2() - ) - ).to_json() - ) - print("fetching prices") - print( ( await api.get_price( @@ -296,45 +243,6 @@ async def do_requests( ).to_json() ) - # trade API - print("fetching open orders for account") - print( - ( - await api.get_open_orders_v2( - get_open_orders_request_v2=proto.GetOpenOrdersRequestV2( - order_id="", - client_order_id=0, - market="SOLUSDC", - address=public_key, - limit=0, - ) - ) - ).to_json() - ) - - print("fetching unsettled amounts") - print( - ( - await api.get_unsettled_v2( - get_unsettled_request_v2=proto.GetUnsettledRequestV2( - market="SOLUSDC", - owner_address=public_key, - ) - ) - ).to_json() - ) - - print("fetching account balance amounts") - print( - ( - await api.get_account_balance( - get_account_balance_request=proto.GetAccountBalanceRequest( - owner_address=public_key - ) - ) - ).to_json() - ) - print("fetching token accounts and balances") print( ( @@ -346,129 +254,6 @@ async def do_requests( ).to_json() ) - print( - "generating unsigned order (no sign or submission) to sell 0.1 SOL for" - " USDC at 150_000 USD/SOL" - ) - print( - ( - await api.post_order_v2( - post_order_request_v2=proto.PostOrderRequestV2( - owner_address=public_key, - payer_address=public_key, - market="SOLUSDC", - side="ASK", - amount=0.1, - price=150_000, - type="limit", - # optional, but much faster if known - open_orders_address=open_orders, - # optional, for identification - client_order_id=0, - ) - ) - ).to_json() - ) - if order_id != "": - print("generate cancel order") - print( - ( - await api.post_cancel_order_v2( - post_cancel_order_request_v2=proto.PostCancelOrderRequestV2( - order_id=order_id, - side="ASK", - market_address="SOLUSDC", - owner_address=public_key, - open_orders_address=open_orders, - client_order_id=0, - ) - ) - ).to_json() - ) - - print("generate cancel order by client ID") - print( - await api.post_cancel_order_v2( - post_cancel_order_request_v2=proto.PostCancelOrderRequestV2( - client_order_id=123, - market_address=sol_usdc_market, - owner_address=public_key, - open_orders_address=open_orders, - ) - ) - ) - - print("generate settle order") - print( - await api.post_settle_v2( - post_settle_request_v2=proto.PostSettleRequestV2( - owner_address=public_key, - market="SOLUSDC", - base_token_wallet=public_key, - quote_token_wallet=usdc_wallet, - open_orders_address=open_orders, - ) - ) - ) - - print("generate replace by client order id") - print( - ( - await api.post_replace_order_v2( - post_replace_order_request_v2=proto.PostReplaceOrderRequestV2( - owner_address=public_key, - payer_address=public_key, - market="SOLUSDC", - side="ASK", - type="limit", - amount=0.1, - price=150_000, - # optional, but much faster if known - open_orders_address=open_orders, - # optional, for identification - client_order_id=123, - ) - ) - ).to_json() - ) - if order_id != "": - print("generate replace by order id") - print( - ( - await api.post_replace_order_v2( - post_replace_order_request_v2=proto.PostReplaceOrderRequestV2( - owner_address=public_key, - payer_address=public_key, - market="SOLUSDC", - side="ASK", - amount=0.1, - price=150_000, - # optional, but much faster if known - open_orders_address=open_orders, - # optional, for identification - client_order_id=0, - order_id=order_id, - ) - ) - ).to_json() - ) - - print("generate trade swap") - print( - ( - await api.post_trade_swap( - trade_swap_request=proto.TradeSwapRequest( - project=proto.Project.P_RAYDIUM, - owner_address=public_key, - in_token="So11111111111111111111111111111111111111112", - in_amount=0.01, - out_token="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", - slippage=0.01, - ) - ) - ) - ) - print("generate raydium swap") print( ( diff --git a/bxsolana/examples/stream_utils.py b/bxsolana/examples/stream_utils.py index 289fde5..8bb218c 100644 --- a/bxsolana/examples/stream_utils.py +++ b/bxsolana/examples/stream_utils.py @@ -27,66 +27,6 @@ async def do_stream( item_count = 0 break - print("streaming market depth updates...") - async for response in api.get_market_depths_stream( - get_market_depths_request=proto.GetMarketDepthsRequest( - markets=["SOLUSDC"], limit=10, project=proto.Project.P_OPENBOOK - ) - ): - print(response.to_json()) - item_count += 1 - if item_count == 1: - item_count = 0 - break - - print("streaming orderbook updates...") - async for response in api.get_orderbooks_stream( - get_orderbooks_request=proto.GetOrderbooksRequest( - markets=["SOLUSDC"], project=proto.Project.P_OPENBOOK - ) - ): - print(response.to_json()) - item_count += 1 - if item_count == 1: - item_count = 0 - break - - if run_slow: - print("streaming ticker updates...") - async for response in api.get_tickers_stream( - get_tickers_stream_request=proto.GetTickersStreamRequest( - markets=[ - "BONK/SOL", - "wSOL/RAY", - "BONK/RAY", - "RAY/USDC", - "SOL/USDC", - "SOL/USDC", - "RAY/USDC", - "USDT/USDC", - ], - project=proto.Project.P_OPENBOOK, - ) - ): - print(response.to_json()) - item_count += 1 - if item_count == 1: - item_count = 0 - break - - if run_slow: - print("streaming trade updates...") - async for response in api.get_trades_stream( - get_trades_request=proto.GetTradesRequest( - market="SOLUSDC", project=proto.Project.P_OPENBOOK - ) - ): - print(response.to_json()) - item_count += 1 - if item_count == 1: - item_count = 0 - break - if run_slow: print("streaming swap events...") async for response in api.get_swaps_stream( diff --git a/bxsolana/examples/transaction_request_utils.py b/bxsolana/examples/transaction_request_utils.py deleted file mode 100644 index 21af747..0000000 --- a/bxsolana/examples/transaction_request_utils.py +++ /dev/null @@ -1,167 +0,0 @@ -import random -import sys -from typing import Tuple - -from bxsolana_trader_proto import api as proto -from bxsolana_trader_proto.common import OrderType - -from .. import provider -from .. import transaction - - -# if you run this example with the integration wallet be sure to clean up your work afterward -async def do_transaction_requests( - api: provider.Provider, - run_trades: bool, - owner_addr: str, - payer_addr: str, - open_orders_addr: str, - order_id: str, - usdc_wallet: str, - market: str, -): - if not run_trades: - print("skipping transaction requests: set by environment") - return - - async def submit_order_with_client_id(client_id: int) -> str: - return await api.submit_order( - owner_address=owner_addr, - payer_address=payer_addr, - market=market, - side=proto.Side.S_ASK, - types=[OrderType.OT_LIMIT], - amount=0.1, - price=150_000, - project=proto.Project.P_OPENBOOK, - # optional, but much faster if known - open_orders_address=open_orders_addr, - # optional, for identification - client_order_id=client_id, - ) - - async def submit_order() -> Tuple[int, str]: - _client_order_id = random.randint(1, sys.maxsize) - _signature = await submit_order_with_client_id(_client_order_id) - return _client_order_id, _signature - - print( - "submitting order (generate + sign) to sell 0.1 SOL for USDC at 150_000" - " USD/SOL" - ) - - client_order_id, signature = await submit_order() - print(signature) - - print( - "submitting replace order by client ID (generate + sign) to sell 0.1" - " SOL for USDC at 150_000 USD/SOL" - ) - print( - await api.submit_replace_by_client_order_id( - owner_address=owner_addr, - payer_address=payer_addr, - market=market, - side=proto.Side.S_ASK, - types=[OrderType.OT_LIMIT], - amount=0.1, - price=150_000, - project=proto.Project.P_OPENBOOK, - # optional, but much faster if known - open_orders_address=open_orders_addr, - # optional, for identification - client_order_id=client_order_id, - skip_pre_flight=True, - ) - ) - - print( - "submitting replace order (generate + sign) to sell 0.1 SOL for USDC at" - " 150_000 USD/SOL" - ) - print( - await api.submit_replace_order( - owner_address=owner_addr, - payer_address=payer_addr, - market=market, - side=proto.Side.S_ASK, - types=[OrderType.OT_LIMIT], - amount=0.1, - price=150_000, - project=proto.Project.P_OPENBOOK, - # optional, but much faster if known - open_orders_address=open_orders_addr, - # optional, for identification - client_order_id=0, - order_id=order_id, - ) - ) - - # cancel order example: comment out if want to try replace example - print("submit cancel order") - print( - await api.submit_cancel_order( - order_id=order_id, - side=proto.Side.S_ASK, - market_address=market, - owner_address=owner_addr, - project=proto.Project.P_SERUM, - open_orders_address=open_orders_addr, - ) - ) - - # cancel by client order ID example: comment out if want to try replace example - print("submit cancel order by client ID") - print( - await api.submit_cancel_by_client_order_id( - client_order_id=client_order_id, - market_address=market, - owner_address=owner_addr, - project=proto.Project.P_SERUM, - open_orders_address=open_orders_addr, - skip_pre_flight=True, - ) - ) - - print("submit settle order") - print( - await api.submit_settle( - owner_address=owner_addr, - market=market, - base_token_wallet=owner_addr, - quote_token_wallet=usdc_wallet, - project=proto.Project.P_SERUM, - open_orders_address="", # optional - ) - ) - - print("marking transactions with memo") - await mark_transaction_with_memo(api) - - -async def mark_transaction_with_memo(api: provider.Provider): - private_key = transaction.load_private_key_from_env() - public_key = private_key.pubkey() - response = await api.post_trade_swap( - trade_swap_request=proto.TradeSwapRequest( - project=proto.Project.P_JUPITER, - owner_address=str(public_key), - in_token="USDT", - in_amount=0.01, - out_token="USDC", - slippage=0.01, - ) - ) - - tx = response.transactions[0].content - tx = transaction.add_memo_to_serialized_txn(tx) - - signed_tx = transaction.sign_tx_with_private_key(tx, private_key) - - post_submit_response = await api.post_submit( - post_submit_request=proto.PostSubmitRequest( - transaction=proto.TransactionMessage(signed_tx), - skip_pre_flight=True, - ) - ) - print("signature for single memo txn", post_submit_response.signature) diff --git a/bxsolana/provider/base.py b/bxsolana/provider/base.py index fa29c2e..a1bbd5b 100644 --- a/bxsolana/provider/base.py +++ b/bxsolana/provider/base.py @@ -34,364 +34,6 @@ def require_private_key(self) -> kp.Keypair: raise EnvironmentError("private key has not been set in provider") return kp - async def submit_order( - self, - owner_address: str, - payer_address: str, - market: str, - side: "api.Side", - types: List["OrderType"], - amount: float, - price: float, - open_orders_address: str = "", - client_order_id: int = 0, - compute_limit: int = 0, - compute_price: int = 0, - project: api.Project = api.Project.P_UNKNOWN, - skip_pre_flight: bool = True, - ) -> str: - pk = self.require_private_key() - order = await self.post_order( - post_order_request=api.PostOrderRequest( - owner_address=owner_address, - payer_address=payer_address, - market=market, - side=side, - type=types, - amount=amount, - price=price, - open_orders_address=open_orders_address, - client_order_id=client_order_id, - compute_limit=compute_limit, - compute_price=compute_price, - project=project, - ) - ) - signed_tx = transaction.sign_tx_message_with_private_key( - order.transaction, pk - ) - result = await self.post_submit( - post_submit_request=api.PostSubmitRequest( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - return result.signature - - async def submit_cancel_order( - self, - order_id: str = "", - side: api.Side = api.Side.S_UNKNOWN, - market_address: str = "", - owner_address: str = "", - open_orders_address: str = "", - compute_limit: int = 0, - compute_price: int = 0, - project: api.Project = api.Project.P_UNKNOWN, - skip_pre_flight: bool = True, - ) -> str: - pk = self.require_private_key() - order = await self.post_cancel_order( - post_cancel_order_request=api.PostCancelOrderRequest( - order_id=order_id, - side=side, - market_address=market_address, - owner_address=owner_address, - open_orders_address=open_orders_address, - compute_limit=compute_limit, - compute_price=compute_price, - project=project, - ) - ) - signed_tx = transaction.sign_tx_message_with_private_key( - order.transaction, pk - ) - result = await self.post_submit( - post_submit_request=api.PostSubmitRequest( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - return result.signature - - async def submit_cancel_by_client_order_id( - self, - client_order_id: int = 0, - market_address: str = "", - owner_address: str = "", - open_orders_address: str = "", - compute_limit: int = 0, - compute_price: int = 0, - project: api.Project = api.Project.P_UNKNOWN, - skip_pre_flight: bool = True, - ) -> str: - pk = self.require_private_key() - - order = await self.post_cancel_by_client_order_id( - post_cancel_by_client_order_id_request=api.PostCancelByClientOrderIdRequest( - client_order_id=client_order_id, - market_address=market_address, - owner_address=owner_address, - open_orders_address=open_orders_address, - compute_limit=compute_limit, - compute_price=compute_price, - project=project, - ) - ) - signed_tx = transaction.sign_tx_message_with_private_key( - order.transaction, pk - ) - result = await self.post_submit( - post_submit_request=api.PostSubmitRequest( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - return result.signature - - async def submit_cancel_all( - self, - market: str = "", - owner_address: str = "", - open_orders_addresses: Optional[List[str]] = None, - compute_limit: int = 0, - compute_price: int = 0, - project: api.Project = api.Project.P_UNKNOWN, - skip_pre_flight: bool = True, - ) -> List[str]: - if open_orders_addresses is None: - open_orders_addresses = [] - - pk = self.require_private_key() - response = await self.post_cancel_all( - post_cancel_all_request=api.PostCancelAllRequest( - market=market, - owner_address=owner_address, - open_orders_addresses=open_orders_addresses, - compute_limit=compute_limit, - compute_price=compute_price, - project=project, - ) - ) - - signatures = [] - for tx in response.transactions: - signed_tx = transaction.sign_tx_message_with_private_key(tx, pk) - result = await self.post_submit( - post_submit_request=api.PostSubmitRequest( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - signatures.append(result.signature) - - return signatures - - async def submit_settle( - self, - owner_address: str = "", - market: str = "", - base_token_wallet: str = "", - quote_token_wallet: str = "", - open_orders_address: str = "", - compute_limit: int = 0, - compute_price: int = 0, - project: api.Project = api.Project.P_UNKNOWN, - skip_pre_flight: bool = True, - ) -> str: - pk = self.require_private_key() - response = await self.post_settle( - post_settle_request=api.PostSettleRequest( - owner_address=owner_address, - market=market, - base_token_wallet=base_token_wallet, - quote_token_wallet=quote_token_wallet, - open_orders_address=open_orders_address, - compute_limit=compute_limit, - compute_price=compute_price, - project=project, - ) - ) - signed_tx = transaction.sign_tx_message_with_private_key( - response.transaction, pk - ) - result = await self.post_submit( - post_submit_request=api.PostSubmitRequest( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - return result.signature - - async def submit_replace_by_client_order_id( - self, - owner_address: str, - payer_address: str, - market: str, - side: "api.Side", - types: List["OrderType"], - amount: float, - price: float, - open_orders_address: str = "", - client_order_id: int = 0, - compute_limit: int = 0, - compute_price: int = 0, - project: api.Project = api.Project.P_UNKNOWN, - skip_pre_flight: bool = True, - ) -> str: - pk = self.require_private_key() - order = await self.post_replace_by_client_order_id( - post_order_request=api.PostOrderRequest( - owner_address=owner_address, - payer_address=payer_address, - market=market, - side=side, - type=types, - amount=amount, - price=price, - open_orders_address=open_orders_address, - client_order_id=client_order_id, - compute_limit=compute_limit, - compute_price=compute_price, - project=project, - ) - ) - signed_tx = transaction.sign_tx_message_with_private_key( - order.transaction, pk - ) - result = await self.post_submit( - post_submit_request=api.PostSubmitRequest( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - return result.signature - - async def submit_replace_order( - self, - order_id: str, - owner_address: str, - payer_address: str, - market: str, - side: "api.Side", - types: List["OrderType"], - amount: float, - price: float, - open_orders_address: str = "", - client_order_id: int = 0, - compute_limit: int = 0, - compute_price: int = 0, - project: api.Project = api.Project.P_UNKNOWN, - skip_pre_flight: bool = True, - ) -> str: - pk = self.require_private_key() - order = await self.post_replace_order( - post_replace_order_request=api.PostReplaceOrderRequest( - owner_address=owner_address, - payer_address=payer_address, - market=market, - side=side, - type=types, - amount=amount, - price=price, - open_orders_address=open_orders_address, - client_order_id=client_order_id, - order_id=order_id, - compute_limit=compute_limit, - compute_price=compute_price, - project=project, - ) - ) - signed_tx = transaction.sign_tx_message_with_private_key( - order.transaction, pk - ) - result = await self.post_submit( - post_submit_request=api.PostSubmitRequest( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - return result.signature - - async def submit_post_trade_swap( - self, - *, - project: api.Project = api.Project.P_UNKNOWN, - owner_address: str = "", - in_token: str = "", - out_token: str = "", - in_amount: float = 0, - slippage: float = 0, - compute_limit: int = 0, - compute_price: int = 0, - tip: int = 0, - skip_pre_flight: bool = True, - submit_strategy: api.SubmitStrategy = api.SubmitStrategy.P_ABORT_ON_FIRST_ERROR, - ) -> api.PostSubmitBatchResponse: - pk = self.require_private_key() - result = await self.post_trade_swap( - trade_swap_request=api.TradeSwapRequest( - project=project, - owner_address=owner_address, - in_token=in_token, - out_token=out_token, - in_amount=in_amount, - slippage=slippage, - compute_limit=compute_limit, - compute_price=compute_price, - tip=tip - ) - ) - - signed_txs: List[api.PostSubmitRequestEntry] = [] - for tx in result.transactions: - signed_tx = transaction.sign_tx_message_with_private_key(tx, pk) - signed_txs.append( - api.PostSubmitRequestEntry( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - - return await self.post_submit_batch( - post_submit_batch_request=api.PostSubmitBatchRequest( - entries=signed_txs, submit_strategy=submit_strategy - ) - ) - - async def submit_post_route_trade_swap( - self, - *, - project: api.Project = api.Project.P_UNKNOWN, - owner_address: str = "", - steps: List["api.RouteStep"] = [], - slippage: float = 0, - compute_limit: int = 0, - compute_price: int = 0, - tip: int = 0, - skip_pre_flight: bool = True, - submit_strategy: api.SubmitStrategy = api.SubmitStrategy.P_ABORT_ON_FIRST_ERROR, - ) -> api.PostSubmitBatchResponse: - pk = self.require_private_key() - result = await self.post_route_trade_swap( - route_trade_swap_request=api.RouteTradeSwapRequest( - project=project, - owner_address=owner_address, - steps=steps, - slippage=slippage, - compute_limit=compute_limit, - compute_price=compute_price, - tip=tip, - ) - ) - - signed_txs: List[api.PostSubmitRequestEntry] = [] - for tx in result.transactions: - signed_tx = transaction.sign_tx_message_with_private_key(tx, pk) - signed_txs.append( - api.PostSubmitRequestEntry( - transaction=signed_tx, skip_pre_flight=skip_pre_flight - ) - ) - - return await self.post_submit_batch( - post_submit_batch_request=api.PostSubmitBatchRequest( - entries=signed_txs, submit_strategy=submit_strategy - ) - ) - async def submit_raydium_swap( self, owner_address: str, diff --git a/bxsolana/provider/http.py b/bxsolana/provider/http.py index 2724425..ed5d73c 100644 --- a/bxsolana/provider/http.py +++ b/bxsolana/provider/http.py @@ -371,176 +371,6 @@ async def post_raydium_clmm_route_swap( ) as res: return await map_response(res, proto.PostRaydiumRouteSwapResponse()) - # Openbook V2 - - async def get_markets_v2( - self, - get_markets_request_v2: proto.GetMarketsRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetMarketsResponseV2: - async with self._session.get( - f"{self._endpoint_v2}/openbook/markets" - ) as res: - return await map_response(res, proto.GetMarketsResponseV2()) - - async def get_orderbook_v2( - self, - get_orderbook_request_v2: proto.GetOrderbookRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetOrderbookResponseV2: - async with self._session.get( - f"{self._endpoint_v2}/openbook/orderbooks/{get_orderbook_request_v2.market}?" - f"limit={get_orderbook_request_v2.limit}" - ) as res: - return await map_response(res, proto.GetOrderbookResponseV2()) - - async def get_market_depth_v2( - self, - get_market_depth_request_v2: proto.GetMarketDepthRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetMarketDepthResponseV2: - async with self._session.get( - f"{self._endpoint_v2}/openbook/depth/{get_market_depth_request_v2.market}?limit={get_market_depth_request_v2.limit}" - ) as res: - return await map_response(res, proto.GetMarketDepthResponseV2()) - - async def get_tickers_v2( - self, - get_tickers_request_v2: proto.GetTickersRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetTickersResponseV2: - - print(f"{self._endpoint_v2}/openbook/tickers/{get_tickers_request_v2.market}") - async with self._session.get( - f"{self._endpoint_v2}/openbook/tickers/{get_tickers_request_v2.market}" - ) as res: - return await map_response(res, proto.GetTickersResponseV2()) - - async def get_open_orders_v2( - self, - get_open_orders_request_v2: proto.GetOpenOrdersRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetOpenOrdersResponseV2: - async with self._session.get( - f"{self._endpoint_v2}/openbook/open-orders/{get_open_orders_request_v2.market}" - f"?address={get_open_orders_request_v2.address}" - f"&openOrdersAddress={get_open_orders_request_v2.open_orders_address}" - f"&orderID={get_open_orders_request_v2.order_id}" - f"&clientOrderID={get_open_orders_request_v2.client_order_id}" - ) as res: - return await map_response(res, proto.GetOpenOrdersResponseV2()) - - async def get_unsettled_v2( - self, - get_unsettled_request_v2: proto.GetUnsettledRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetUnsettledResponse: - async with self._session.get( - f"{self._endpoint_v2}/openbook/unsettled/{get_unsettled_request_v2.market}?" - f"ownerAddress={get_unsettled_request_v2.owner_address}&" - ) as res: - return await map_response(res, proto.GetUnsettledResponse()) - - async def post_order_v2( - self, - post_order_request_v2: proto.PostOrderRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostOrderResponse: - async with self._session.post( - f"{self._endpoint_v2}/openbook/place", - json=post_order_request_v2.to_dict(), - ) as res: - return await map_response(res, proto.PostOrderResponse()) - - async def post_cancel_order_v2( - self, - post_cancel_order_request_v2: proto.PostCancelOrderRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostCancelOrderResponseV2: - request_dict = post_cancel_order_request_v2.to_dict() - if "orderId" in request_dict: - request_dict["orderID"] = request_dict.pop("orderId") - if "clientOrderId" in request_dict: - request_dict["clientOrderID"] = request_dict.pop("clientOrderId") - async with self._session.post( - f"{self._endpoint_v2}/openbook/cancel", - json=request_dict, - ) as res: - return await map_response(res, proto.PostCancelOrderResponseV2()) - - async def post_settle_v2( - self, - post_settle_request_v2: proto.PostSettleRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostSettleResponse: - async with self._session.post( - f"{self._endpoint_v2}/openbook/settle", - json=post_settle_request_v2.to_dict(), - ) as res: - return await map_response(res, proto.PostSettleResponse()) - - async def post_replace_order_v2( - self, - post_replace_order_request_v2: proto.PostReplaceOrderRequestV2, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostOrderResponse: - request_dict = post_replace_order_request_v2.to_dict() - if "orderId" in request_dict: - request_dict["orderID"] = request_dict.pop("orderId") - if "clientOrderId" in request_dict: - request_dict["clientOrderID"] = request_dict.pop("clientOrderId") - - async with self._session.post( - f"{self._endpoint_v2}/openbook/replace", - json=request_dict, - ) as res: - return await map_response(res, proto.PostOrderResponse()) - - # End of Openbook V2 - - # End of V2 - - async def get_markets( - self, - get_markets_request: proto.GetMarketsRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetMarketsResponse: - async with self._session.get(f"{self._endpoint}/market/markets") as res: - return await map_response(res, proto.GetMarketsResponse()) - async def get_quotes( self, get_quotes_request: proto.GetQuotesRequest, @@ -557,127 +387,6 @@ async def get_quotes( ) as res: return await map_response(res, proto.GetQuotesResponse()) - async def post_route_trade_swap( - self, - route_trade_swap_request: proto.RouteTradeSwapRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.TradeSwapResponse: - async with self._session.post( - f"{self._endpoint}/trade/route-swap", - json=route_trade_swap_request.to_dict(), - ) as res: - return await map_response(res, proto.TradeSwapResponse()) - - async def get_orderbook( - self, - get_orderbook_request: proto.GetOrderbookRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetOrderbookResponse: - async with self._session.get( - f"{self._endpoint}/market/orderbooks/{get_orderbook_request.market}?" - f"limit={get_orderbook_request.limit}&project={get_orderbook_request.project.name}" - ) as res: - return await map_response(res, proto.GetOrderbookResponse()) - - async def get_market_depth( - self, - get_market_depth_request: proto.GetMarketDepthRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetMarketDepthResponse: - async with self._session.get( - f"{self._endpoint}/market/depth/{get_market_depth_request.market}?limit={get_market_depth_request.limit}" - f"&project={get_market_depth_request.project.name}" - ) as res: - return await map_response(res, proto.GetMarketDepthResponse()) - - async def get_tickers( - self, - get_tickers_request: proto.GetTickersRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetTickersResponse: - async with self._session.get( - f"{self._endpoint}/market/tickers/{get_tickers_request.market}?project={get_tickers_request.project.name}" - ) as res: - return await map_response(res, proto.GetTickersResponse()) - - async def get_orders( - self, - get_orders_request: proto.GetOrdersRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetOrdersResponse: - raise NotImplementedError() - - async def get_open_orders( - self, - get_open_orders_request: proto.GetOpenOrdersRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetOpenOrdersResponse: - async with self._session.get( - f"{self._endpoint}/trade/orders/{get_open_orders_request.market}" - f"?address={get_open_orders_request.address}" - f"&openOrdersAddress={get_open_orders_request.open_orders_address}" - "&types=OT_LIMIT" - f"&project={get_open_orders_request.project.name}" - ) as res: - return await map_response(res, proto.GetOpenOrdersResponse()) - - async def get_order_by_id( - self, - get_order_by_id_request: proto.GetOrderByIdRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetOrderByIdResponse: - # TODO - raise NotImplementedError() - - async def get_unsettled( - self, - get_unsettled_request: proto.GetUnsettledRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetUnsettledResponse: - async with self._session.get( - f"{self._endpoint}/trade/unsettled/{get_unsettled_request.market}?" - f"ownerAddress={get_unsettled_request.owner_address}&" - f"project={get_unsettled_request.project.name}" - ) as res: - return await map_response(res, proto.GetUnsettledResponse()) - - async def get_account_balance( - self, - get_account_balance_request: proto.GetAccountBalanceRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.GetAccountBalanceResponse: - async with self._session.get( - f"{self._endpoint_v2}/balance?ownerAddress={get_account_balance_request.owner_address}" - ) as res: - return await map_response(res, proto.GetAccountBalanceResponse()) - async def get_token_accounts( self, get_token_accounts_request: proto.GetTokenAccountsRequest, @@ -776,100 +485,6 @@ async def get_priority_fee_by_program( async with self._session.get(url) as res: return await map_response(res, proto.GetPriorityFeeByProgramResponse()) - async def post_trade_swap( - self, - trade_swap_request: proto.TradeSwapRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.TradeSwapResponse: - async with self._session.post( - f"{self._endpoint}/trade/swap", json=trade_swap_request.to_dict() - ) as res: - return await map_response(res, proto.TradeSwapResponse()) - - async def post_order( - self, - post_order_request: proto.PostOrderRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostOrderResponse: - # the to_dict() call below will give use a field name of clientOrderId, - # however we need clientOrderID (id is capitalized, not camelCase). This - # code snippet will adjust the dictionary for us. - json = post_order_request.to_dict() - jsonFixed = { - "clientOrderID" if k == "clientOrderId" else k: v - for k, v in json.items() - } - async with self._session.post( - f"{self._endpoint}/trade/place", json=jsonFixed - ) as res: - return await map_response(res, proto.PostOrderResponse()) - - async def post_cancel_order( - self, - post_cancel_order_request: proto.PostCancelOrderRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostCancelOrderResponse: - request_dict = post_cancel_order_request.to_dict() - if "orderId" in request_dict: - request_dict["orderID"] = request_dict.pop("orderId") - async with self._session.post( - f"{self._endpoint}/trade/cancel", - json=request_dict, - ) as res: - return await map_response(res, proto.PostCancelOrderResponse()) - - async def post_cancel_by_client_order_id( - self, - post_cancel_by_client_order_id_request: proto.PostCancelByClientOrderIdRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostCancelOrderResponse: - request_dict = post_cancel_by_client_order_id_request.to_dict() - if "clientOrderId" in request_dict: - request_dict["clientOrderID"] = request_dict.pop("clientOrderId") - async with self._session.post( - f"{self._endpoint}/trade/cancelbyid", json=request_dict - ) as res: - return await map_response(res, proto.PostCancelOrderResponse()) - - async def post_cancel_all( - self, - post_cancel_all_request: proto.PostCancelAllRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostCancelAllResponse: - async with self._session.post( - f"{self._endpoint}/trade/cancelall", - json=post_cancel_all_request.to_dict(), - ) as res: - return await map_response(res, proto.PostCancelAllResponse()) - - async def post_settle( - self, - post_settle_request: proto.PostSettleRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostSettleResponse: - async with self._session.post( - f"{self._endpoint}/trade/settle", json=post_settle_request.to_dict() - ) as res: - return await map_response(res, proto.PostSettleResponse()) - async def post_submit( self, post_submit_request: proto.PostSubmitRequest, @@ -934,40 +549,6 @@ async def post_submit_batch_v2( ) as res: return await map_response(res, proto.PostSubmitBatchResponse()) - async def post_replace_by_client_order_id( - self, - post_order_request: proto.PostOrderRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostOrderResponse: - request_dict = post_order_request.to_dict() - if "clientOrderId" in request_dict: - request_dict["clientOrderID"] = request_dict.pop("clientOrderId") - async with self._session.post( - f"{self._endpoint}/trade/replacebyclientid", json=request_dict - ) as res: - return await map_response(res, proto.PostOrderResponse()) - - async def post_replace_order( - self, - post_replace_order_request: proto.PostReplaceOrderRequest, - *, - timeout: Optional[float] = None, - deadline: Optional["Deadline"] = None, - metadata: Optional["MetadataLike"] = None, - ) -> proto.PostOrderResponse: - request_dict = post_replace_order_request.to_dict() - if "orderId" in request_dict: - request_dict["orderID"] = request_dict.pop("orderId") - - async with self._session.post( - f"{self._endpoint}/trade/replace", - json=request_dict, - ) as res: - return await map_response(res, proto.PostOrderResponse()) - async def _unary_stream( self, route: str, diff --git a/example/transaction/main.py b/example/transaction/main.py deleted file mode 100644 index 7b557b5..0000000 --- a/example/transaction/main.py +++ /dev/null @@ -1,145 +0,0 @@ -import asyncio -import os - -from bxsolana_trader_proto import api as proto -from bxsolana_trader_proto.common import OrderType - -from bxsolana import provider, examples - -# TODO: Add some logic here to indicate to user if missing needed environment variables for tests -public_key = os.getenv("PUBLIC_KEY") -private_key = os.getenv("PRIVATE_KEY") -open_orders = os.getenv("OPEN_ORDERS") -base_token_wallet = os.getenv("BASE_TOKEN_WALLET") -quote_token_wallet = os.getenv("QUOTE_TOKEN_WALLET") - -market_addr = "9wFFyRfZBsuAha4YcuxcXLKwMxJR43S7fPfQLusDBzvT" # SOL/USDC -order_side = proto.Side.S_ASK -order_type = OrderType.OT_LIMIT -order_price = 170200 -order_amount = 0.1 - - -async def main(): - await ws() - await grpc() - await http() - - -async def ws(): - print("\n*** WS Test ***\n") - async with provider.ws() as api: - async with provider.ws() as api2: # TODO use same provider when WS streams are separated - await examples.order_lifecycle( - p1=api, - p2=api2, - owner_addr=public_key, - payer_addr=public_key, - market_addr=market_addr, - order_side=order_side, - order_type=order_type, - order_amount=order_amount, - order_price=order_price, - open_orders_addr=open_orders, - base_token_wallet=base_token_wallet, - quote_token_wallet=quote_token_wallet, - ) - - await examples.cancel_all_orders( - api, - owner_addr=public_key, - payer_addr=public_key, - order_side=order_side, - order_type=order_type, - order_amount=order_amount, - order_price=order_price, - open_orders_addr=open_orders, - market_addr=market_addr, - ) - - await examples.replace_order_by_client_order_id( - api, - owner_addr=public_key, - payer_addr=public_key, - market_addr=market_addr, - order_side=order_side, - order_type=order_type, - order_amount=order_amount, - order_price=order_price, - open_orders_addr=open_orders, - ) - - -async def grpc(): - print("\n*** GRPC Test ***\n") - async with provider.grpc() as api: - await examples.order_lifecycle( - p1=api, - p2=api, - owner_addr=public_key, - payer_addr=public_key, - market_addr=market_addr, - order_side=order_side, - order_type=order_type, - order_amount=order_amount, - order_price=order_price, - open_orders_addr=open_orders, - base_token_wallet=base_token_wallet, - quote_token_wallet=quote_token_wallet, - ) - - await examples.cancel_all_orders( - api, - owner_addr=public_key, - payer_addr=public_key, - order_side=order_side, - order_type=order_type, - order_amount=order_amount, - order_price=order_price, - open_orders_addr=open_orders, - market_addr=market_addr, - ) - - await examples.replace_order_by_client_order_id( - api, - owner_addr=public_key, - payer_addr=public_key, - market_addr=market_addr, - order_side=order_side, - order_type=order_type, - order_amount=order_amount, - order_price=order_price, - open_orders_addr=open_orders, - ) - - -async def http(): - print("\n*** HTTP Test ***\n") - async with provider.http() as api: - await examples.cancel_all_orders( - api, - owner_addr=public_key, - payer_addr=public_key, - order_side=order_side, - order_type=order_type, - order_amount=order_amount, - order_price=order_price, - open_orders_addr=open_orders, - market_addr=market_addr, - ) - - await examples.replace_order_by_client_order_id( - api, - owner_addr=public_key, - payer_addr=public_key, - market_addr=market_addr, - order_side=order_side, - order_type=order_type, - order_amount=order_amount, - order_price=order_price, - open_orders_addr=open_orders, - ) - - -if __name__ == "__main__": - asyncio.run(main()) diff --git a/helpers.py b/helpers.py index 2b5bed6..d8ef3e2 100644 --- a/helpers.py +++ b/helpers.py @@ -61,10 +61,6 @@ def initializeEnvironmentVariables() -> EnvironmentVariables: if not public_key: logger.warning("PUBLIC_KEY environment variable not set. Will skip place/cancel/settle examples.") - open_orders_address = os.getenv("OPEN_ORDERS") - if not open_orders_address: - logger.error("OPEN_ORDERS environment variable not set. Requests may be slower.") - payer = os.getenv("PAYER") if not payer: if public_key: @@ -77,7 +73,6 @@ def initializeEnvironmentVariables() -> EnvironmentVariables: return EnvironmentVariables( private_key=private_key or "", public_key=public_key or "", - open_orders_address=open_orders_address or "", payer=payer ) @@ -85,12 +80,6 @@ def initializeEnvironmentVariables() -> EnvironmentVariables: UserEnvironment = initializeEnvironmentVariables() -async def get_markets(p: provider.Provider) -> bool: - resp = await p.get_markets_v2(proto.GetMarketsRequestV2()) - pprint(resp) - - return True if resp.markets is not None else False - async def get_pools(p: provider.Provider) -> bool: resp = await p.get_pools(proto.GetPoolsRequest(projects=[proto.Project.P_RAYDIUM])) @@ -98,13 +87,6 @@ async def get_pools(p: provider.Provider) -> bool: return True if resp is not None else False -async def get_tickers(p: provider.Provider) -> bool: - resp = await p.get_tickers_v2(proto.GetTickersRequestV2(market="SOLUSDC")) - pprint(resp) - - return True if resp.tickers is not None else False - - async def get_raydium_clmm_pools(p: provider.Provider) -> bool: resp = await p.get_raydium_clmm_pools(proto.GetRaydiumClmmPoolsRequest()) pprint(resp) @@ -112,13 +94,6 @@ async def get_raydium_clmm_pools(p: provider.Provider) -> bool: return True if resp.pools is not None else False -async def get_orderbook(p: provider.Provider) -> bool: - resp = await p.get_orderbook_v2(proto.GetOrderbookRequestV2("SOL-USDC")) - pprint(resp) - - return True if resp.market is not None else False - - async def get_raydium_pool_reserves(p: provider.Provider) -> bool: resp = await p.get_raydium_pool_reserve(proto.GetRaydiumPoolReserveRequest( pairs_or_addresses=["HZ1znC9XBasm9AMDhGocd9EHSyH8Pyj1EUdiPb4WnZjo", @@ -127,22 +102,6 @@ async def get_raydium_pool_reserves(p: provider.Provider) -> bool: return True if resp.pools is not None else False - -async def get_market_depth(p: provider.Provider) -> bool: - resp = await p.get_market_depth_v2(proto.GetMarketDepthRequestV2(market="SOLUSDC")) - pprint(resp) - - return True if resp.market is not None else False - - -async def get_open_orders(p: provider.Provider) -> bool: - resp = await p.get_open_orders_v2( - proto.GetOpenOrdersRequestV2(market="SOLUSDC", address="FFqDwRq8B4hhFKRqx7N1M6Dg6vU699hVqeynDeYJdPj5")) - pprint(resp) - - return True if resp.orders is not None else False - - async def get_transaction(p: provider.Provider) -> bool: resp = await p.get_transaction( proto.GetTransactionRequest( @@ -205,29 +164,6 @@ async def get_jupiter_prices(p: provider.Provider) -> bool: return True if resp.token_prices is not None else False - -async def get_unsettled(p: provider.Provider) -> bool: - resp = await p.get_unsettled_v2( - proto.GetUnsettledRequestV2(market="SOLUSDC", owner_address="HxFLKUAmAMLz1jtT3hbvCMELwH5H9tpM2QugP8sKyfhc")) - pprint(resp) - - return True if resp.market is not None else False - - -async def get_account_balance(p: provider.Provider) -> bool: - if UserEnvironment.public_key != "": - resp = await p.get_account_balance_v2( - proto.GetAccountBalanceRequest(owner_address=UserEnvironment.public_key)) - pprint(resp) - - else: - resp = await p.get_account_balance_v2( - proto.GetAccountBalanceRequest(owner_address="HxFLKUAmAMLz1jtT3hbvCMELwH5H9tpM2QugP8sKyfhc")) - pprint(resp) - - return True if resp.tokens is not None else False - - async def get_quotes(p: provider.Provider) -> bool: resp = await p.get_quotes(proto.GetQuotesRequest(in_token="So11111111111111111111111111111111111111112", out_token="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", @@ -322,63 +258,6 @@ async def get_token_accounts(p: provider.Provider) -> bool: return True if resp.accounts is not None else False - -async def orderbook_stream(p: provider.Provider) -> bool: - print("streaming orderbook updates...") - - async for resp in p.get_orderbooks_stream( - get_orderbooks_request=proto.GetOrderbooksRequest( - markets=["SOLUSDC"], project=proto.Project.P_OPENBOOK - ) - ): - pprint(resp) - await p.close() - - return True if resp.orderbook is not None else False - return False - - -async def market_depth_stream(p: provider.Provider) -> bool: - print("streaming market depth updates...") - - async for resp in p.get_market_depths_stream( - get_market_depths_request=proto.GetMarketDepthsRequest( - markets=["SOLUSDC"], limit=5, project=proto.Project.P_OPENBOOK - ), - timeout=10, - ): - pprint(resp) - await p.close() - - return True if resp.data is not None else False - return False - - -async def get_tickers_stream(p: provider.Provider) -> bool: - print("streaming ticker updates...") - - async for resp in p.get_tickers_stream(timeout=10, - get_tickers_stream_request=proto.GetTickersStreamRequest( - markets=[ - "BONK/SOL", - "wSOL/RAY", - "BONK/RAY", - "RAY/USDC", - "SOL/USDC", - "SOL/USDC", - "RAY/USDC", - "USDT/USDC", - ], - project=proto.Project.P_OPENBOOK, - ) - ): - pprint(resp) - await p.close() - - return True if resp.ticker is not None else False - return False - - async def get_prices_stream(p: provider.Provider) -> bool: print("streaming price streams...") async for resp in p.get_prices_stream( @@ -418,21 +297,6 @@ async def get_swaps_stream(p: provider.Provider) -> bool: return True if resp.swap is not None else False return False - -async def get_trades_stream(p: provider.Provider) -> bool: - print("streaming trade updates...") - async for resp in p.get_trades_stream( - get_trades_request=proto.GetTradesRequest( - market="SOLUSDC", project=proto.Project.P_OPENBOOK - ) - ): - pprint(resp) - - await p.close() - return True if resp.trades is not None else False - return False - - async def get_new_raydium_pools_stream(p: provider.Provider) -> bool: print("streaming raydium new pool updates without cpmm pools...") async for resp in p.get_new_raydium_pools_stream( @@ -542,49 +406,6 @@ async def get_priority_fee_by_program_stream(p: provider.Provider) -> bool: return True if resp.data is not None else False return False -async def call_trade_swap(p: provider.Provider) -> bool: - print("calling post submit trade swap (using batch submit)...") - - response = await p.submit_post_trade_swap(project=proto.Project.P_RAYDIUM, - owner_address=UserEnvironment.public_key, - in_token="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", - out_token="So11111111111111111111111111111111111111112", - in_amount=0.01, - slippage=0.5, - compute_limit=200000, - compute_price=100000, - tip=1000000, - submit_strategy=proto.SubmitStrategy.P_ABORT_ON_FIRST_ERROR, - skip_pre_flight=True) - - print("signature for trade swap tx", response.transactions[0].signature) - - return True if response.transactions[0].signature else False - - -async def call_route_trade_swap(p: provider.Provider) -> bool: - print("calling post submit route trade swap (using batch submit)...") - - response = await p.submit_post_route_trade_swap(project=proto.Project.P_RAYDIUM, - owner_address=UserEnvironment.public_key, - slippage=0.5, - compute_price=100000, - compute_limit=200000, - tip=1000000, - steps=[proto.RouteStep( - in_token="So11111111111111111111111111111111111111112", - out_token="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", - in_amount=0.01, - out_amount_min=0.007505, - out_amount=0.0074, - project=proto.StepProject(label="Raydium", - id="58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"))]) - - print("signature for route trade swap tx", response.transactions[0].signature) - - return True if response.transactions[0].signature else False - - async def call_raydium_trade_swap(p: provider.Provider) -> bool: print("calling post submit raydium trade swap...") diff --git a/sdk.py b/sdk.py index 0c26ae9..78f8d00 100644 --- a/sdk.py +++ b/sdk.py @@ -10,15 +10,15 @@ from bxsolana.provider import constants from menu import MenuSelection -from helpers import Endpoint, get_markets, get_pools, get_tickers, get_raydium_clmm_pools, \ - get_orderbook, get_raydium_pool_reserves, get_market_depth, get_open_orders, get_transaction, get_recent_blockhash, \ +from helpers import Endpoint, get_pools, get_raydium_clmm_pools, \ + get_raydium_pool_reserves, get_transaction, get_recent_blockhash, \ get_recent_blockhash_offset, get_rate_limit, get_price, get_raydium_pools, get_raydium_prices, get_jupiter_prices, \ - get_unsettled, get_account_balance, get_quotes, get_raydium_quotes, get_raydium_cpmm_quotes, \ - get_raydium_clmm_quotes, get_jupiter_quotes, get_pump_fun_quotes, get_leader_schedule, orderbook_stream, market_depth_stream, \ - get_tickers_stream, get_prices_stream, get_swaps_stream, get_trades_stream, get_new_raydium_pools_stream, \ + get_quotes, get_raydium_quotes, get_raydium_cpmm_quotes, \ + get_raydium_clmm_quotes, get_jupiter_quotes, get_pump_fun_quotes, get_leader_schedule, \ + get_prices_stream, get_swaps_stream, get_new_raydium_pools_stream, \ get_new_raydium_pools_stream_cpmm, get_recent_blockhash_stream, get_pool_reserve_stream, \ get_block_stream, get_priority_fee, get_priority_fee_stream, get_bundle_tip_stream, get_priority_fee_by_program_stream, get_token_accounts, \ - call_trade_swap, call_route_trade_swap, call_raydium_trade_swap, call_raydium_cpmm_trade_swap, \ + call_raydium_trade_swap, call_raydium_cpmm_trade_swap, \ call_raydium_clmm_trade_swap, call_jupiter_trade_swap, call_pump_fun_trade_swap, create_personal_tx_and_submit, call_submit_snipe nest_asyncio.apply() @@ -42,15 +42,10 @@ def print_logo(): ExampleEndpoints = { - "get_markets": Endpoint(func=get_markets, requires_additional_env_vars=False), "get_pools": Endpoint(func=get_pools, requires_additional_env_vars=False), - "get_tickers": Endpoint(func=get_tickers, requires_additional_env_vars=False), "get_raydium_clmm_pools": Endpoint(func=get_raydium_clmm_pools, requires_additional_env_vars=False), "get_raydium_pool_reserve": Endpoint(func=get_raydium_pool_reserves, requires_additional_env_vars=False), "get_raydium_pools": Endpoint(func=get_raydium_pools, requires_additional_env_vars=False), - "get_orderbook": Endpoint(func=get_orderbook, requires_additional_env_vars=False), - "get_market_depth": Endpoint(func=get_market_depth, requires_additional_env_vars=False), - "get_open_orders": Endpoint(func=get_open_orders, requires_additional_env_vars=False), "get_transaction": Endpoint(func=get_transaction, requires_additional_env_vars=False), "get_recent_blockhash": Endpoint(func=get_recent_blockhash, requires_additional_env_vars=False), "get_recent_blockhash_offset": Endpoint(func=get_recent_blockhash_offset, requires_additional_env_vars=False), @@ -60,8 +55,6 @@ def print_logo(): "get_price": Endpoint(func=get_price, requires_additional_env_vars=False), "get_raydium_prices": Endpoint(func=get_raydium_prices, requires_additional_env_vars=False), "get_jupiter_prices": Endpoint(func=get_jupiter_prices, requires_additional_env_vars=False), - "get_unsettled": Endpoint(func=get_unsettled, requires_additional_env_vars=False), - "get_account_balance": Endpoint(func=get_account_balance, requires_additional_env_vars=False), "get_quotes": Endpoint(func=get_quotes, requires_additional_env_vars=False), "get_raydium_quotes": Endpoint(func=get_raydium_quotes, requires_additional_env_vars=False), "get_raydium_cpmm_quotes": Endpoint(func=get_raydium_cpmm_quotes, requires_additional_env_vars=False), @@ -71,12 +64,8 @@ def print_logo(): "get_leader_schedule": Endpoint(func=get_leader_schedule, requires_additional_env_vars=False), # streaming endpoints - "orderbook_stream": Endpoint(func=orderbook_stream, requires_additional_env_vars=False), - "market_depth_stream": Endpoint(func=market_depth_stream, requires_additional_env_vars=False), - "tickers_stream": Endpoint(func=get_tickers_stream, requires_additional_env_vars=False), "prices_stream": Endpoint(func=get_prices_stream, requires_additional_env_vars=False), "swaps_stream": Endpoint(func=get_swaps_stream, requires_additional_env_vars=False), - "trades_stream": Endpoint(func=get_trades_stream, requires_additional_env_vars=False), "new_raydium_pools_stream": Endpoint(func=get_new_raydium_pools_stream, requires_additional_env_vars=False), "new_raydium_pools_stream_cpmm": Endpoint(func=get_new_raydium_pools_stream_cpmm, requires_additional_env_vars=False), @@ -89,8 +78,6 @@ def print_logo(): requires_additional_env_vars=False), # transaction endpoints - "trade_swap": Endpoint(func=call_trade_swap, requires_additional_env_vars=True), - "route_trade_swap": Endpoint(func=call_route_trade_swap, requires_additional_env_vars=True), "raydium_swap": Endpoint(func=call_raydium_trade_swap, requires_additional_env_vars=True), "raydium_cpmm_swap": Endpoint(func=call_raydium_cpmm_trade_swap, requires_additional_env_vars=True), "raydium_clmm_swap": Endpoint(func=call_raydium_clmm_trade_swap, requires_additional_env_vars=True), diff --git a/setup.cfg b/setup.cfg index 0d9aaca..6a700c8 100644 --- a/setup.cfg +++ b/setup.cfg @@ -3,7 +3,7 @@ [metadata] name = bxsolana-trader -version = 2.2.0 +version = 2.2.1 description = Python SDK for bloXroute's Solana Trader API long_description = file: README.md, LICENSE long_description_content_type = text/markdown @@ -23,4 +23,4 @@ install_requires = solana==0.31.0 solders==0.19.0 bx-jsonrpc-py==0.2.0 - bxsolana-trader-proto==0.0.97 + bxsolana-trader-proto==0.0.98