pyaver.user_market

  1from copy import deepcopy
  2from pydash import chunk
  3from .market import AverMarket
  4from solana.publickey import PublicKey
  5from asyncio import gather
  6from .checks import *
  7from solana.transaction import AccountMeta
  8from solana.keypair import Keypair
  9from solana.system_program import SYS_PROGRAM_ID
 10from spl.token.constants import TOKEN_PROGRAM_ID
 11from anchorpy import Context
 12from .user_host_lifetime import UserHostLifetime
 13from spl.token.instructions import get_associated_token_address
 14from .aver_client import AverClient
 15from .utils import sign_and_send_transaction_instructions, load_multiple_account_states, parse_user_market_state
 16from solana.rpc.types import TxOpts
 17from solana.rpc.commitment import Finalized
 18from .data_classes import UserHostLifetimeState, UserMarketState, UserBalanceState
 19from .constants import AVER_PROGRAM_ID, AVER_HOST_ACCOUNT, CANCEL_ALL_ORDERS_INSTRUCTION_CHUNK_SIZE
 20from .enums import OrderType, SelfTradeBehavior, Side, SizeFormat
 21import math
 22
 23class UserMarket():
 24    """
 25    Contains data on a user's orders on a particular market (for a particular host)
 26    """
 27
 28    aver_client: AverClient
 29    """
 30    AverClient object
 31    """
 32    pubkey: PublicKey
 33    """
 34    UserMarket public key
 35    """
 36    market: AverMarket
 37    """
 38    Corresponding Market object
 39    """
 40    user_market_state: UserMarketState
 41    """
 42    UserMarketState object
 43    """
 44    user_balance_state: UserBalanceState
 45    """
 46    UserBalanceState object
 47    """
 48    user_host_lifetime: UserHostLifetime
 49    """
 50    UserHostLifetime object
 51    """
 52
 53
 54    def __init__(self, aver_client: AverClient, pubkey: PublicKey, user_market_state: UserMarketState, market: AverMarket, user_balance_state: UserBalanceState, user_host_lifetime: UserHostLifetime):
 55        """
 56         Initialise an UserMarket object. Do not use this function; use UserMarket.load() instead
 57
 58        Args:
 59            aver_client (AverClient): AverClient object
 60            pubkey (PublicKey): UserMarket public key
 61            user_market_state (UserMarketState): UserMarketState object
 62            market (AverMarket): Market object
 63            user_balance_state (UserBalanceState): UserBalanceState object
 64            user_host_lifetime (UserHostLifetime): UserHostLifetime object
 65        """
 66        self.user_market_state = user_market_state
 67        self.pubkey = pubkey
 68        self.aver_client = aver_client
 69        self.market = market
 70        self.user_balance_state = user_balance_state
 71        self.user_host_lifetime = user_host_lifetime
 72
 73    @staticmethod
 74    async def load(
 75            aver_client: AverClient, 
 76            market: AverMarket, 
 77            owner: PublicKey, 
 78            host: PublicKey = AVER_HOST_ACCOUNT,
 79            program_id: PublicKey = AVER_PROGRAM_ID
 80        ):
 81            """
 82            Initialises an UserMarket object from Market, Host and Owner public keys
 83
 84            To refresh data on an already loaded UserMarket use src.refresh.refresh_user_market()
 85
 86            Args:
 87                aver_client (AverClient): AverClient object
 88                market (AverMarket): Corresponding Market object
 89                owner (PublicKey): Owner of UserMarket account
 90                host (PublicKey, optional): Host account public key. Defaults to AVER_HOST_ACCOUNT.
 91                program_id (PublicKey, optional): Program public key. Defaults to AVER_PROGRAM_ID.
 92
 93            Returns:
 94                UserMarket: UserMarket object
 95            """
 96            uma, bump = UserMarket.derive_pubkey_and_bump(owner, market.market_pubkey, host, program_id)
 97            uhl = UserHostLifetime.derive_pubkey_and_bump(owner, host, program_id)[0]
 98            return await UserMarket.load_by_uma(aver_client, uma, market, uhl)
 99
100    @staticmethod
101    async def load_multiple(
102            aver_client: AverClient, 
103            markets: list[AverMarket], 
104            owners: list[PublicKey], 
105            host: PublicKey = AVER_HOST_ACCOUNT,
106            program_id: PublicKey = AVER_PROGRAM_ID,
107        ):
108            """
109            Initialises multiple UserMarket objects from Market, Host and Owner public keys
110
111            This method is more highly optimized and faster than using UserMarket.load() multiple times.
112
113            To refresh data on already loaded UserMarkets use src.refresh.refresh_multiple_user_markets()
114
115            Args:
116                aver_client (AverClient): AverClient object
117                markets (list[AverMarket]): List of corresponding AverMarket objects (in correct order)
118                owner (PublicKey): List of owners of UserMarket account
119                host (PublicKey, optional): Host account public key. Defaults to AVER_HOST_ACCOUNT.
120                program_id (PublicKey, optional): Program public key. Defaults to AVER_PROGRAM_ID.
121
122            Returns:
123                list[UserMarket]: List of UserMarket objects
124            """
125            umas = []
126            for i, m in enumerate(markets):
127                umas.append(UserMarket.derive_pubkey_and_bump(owners[i], m.market_pubkey, host, program_id)[0])
128            uhls = [UserHostLifetime.derive_pubkey_and_bump(owner, host, program_id)[0] for owner in owners]
129            return await UserMarket.load_multiple_by_uma(aver_client, umas, markets, uhls)
130
131    @staticmethod
132    async def load_by_uma(
133            aver_client: AverClient,
134            pubkey: PublicKey,
135            market: (AverMarket or PublicKey),
136            uhl: PublicKey
137        ):
138        """
139        Initialises an UserMarket object from UserMarket account public key
140
141        To refresh data on an already loaded UserMarket use src.refresh.refresh_user_market()
142
143        Args:
144            aver_client (AverClient): AverClient object
145            pubkey (PublicKey): UserMarket account public key
146            market (AverMarket or PublicKey): AverMarket object or AverMarket public key
147            uhl (PublicKey): UserHostLifetime account
148
149        Returns:
150            UserMarket: UserMarket object
151        """
152        res: UserMarketState = await aver_client.program.account['UserMarket'].fetch(pubkey)
153        uhl = await UserHostLifetime.load(aver_client, uhl)
154
155        lamport_balance = await aver_client.request_lamport_balance(res.user)
156        token_balance = await aver_client.request_token_balance(aver_client.quote_token, res.user)
157        user_balance_state = UserBalanceState(lamport_balance, token_balance)
158
159        if(isinstance(market, PublicKey)):
160            market = await AverMarket.load(aver_client, market)
161
162        if(res.market.to_base58() != market.market_pubkey.to_base58()):
163            raise Exception('UserMarket and Market do not match')
164
165        return UserMarket(aver_client, pubkey, res, market, user_balance_state, uhl)   
166    
167    @staticmethod
168    async def load_multiple_by_uma(
169            aver_client: AverClient,
170            pubkeys: list[PublicKey],
171            markets: list[AverMarket],
172            uhls: list[PublicKey]
173        ):
174        """
175        Initialises an multiple UserMarket objects from a list of UserMarket account public keys
176
177        To refresh data on an already loaded UserMarket use src.refresh.refresh_user_markets()
178
179        Args:
180            aver_client (AverClient): AverClient object 
181            pubkeys (list[PublicKey]): List of UserMarket account public keys
182            markets (list[AverMarket]): List of AverMarket objects
183            uhls (list[PublicKey]): List of UserHostLifetime  account public keys
184
185        Raises:
186            Exception: UserMarket and market do not match
187
188        Returns:
189            list[UserMarket]: List of UserMarket objects
190        """
191
192        res: list[UserMarketState] = await aver_client.program.account['UserMarket'].fetch_multiple(pubkeys)
193        uhls = await UserHostLifetime.load_multiple(aver_client, uhls)
194
195        user_pubkeys = [u.user for u in res]
196        user_balances = (await load_multiple_account_states(aver_client, [], [], [], [], user_pubkeys))['user_balance_states']
197
198        umas: list[UserMarket] = []
199        for i, pubkey in enumerate(pubkeys):
200            if(res[i].market.to_base58() != markets[i].market_pubkey.to_base58()):
201                raise Exception('UserMarket and Market do not match')
202            umas.append(UserMarket(aver_client, pubkey, res[i], markets[i], user_balances[i], uhls[i]))
203        return umas
204    
205    @staticmethod
206    def get_user_markets_from_account_state(
207            aver_client: AverClient, 
208            pubkeys: list[PublicKey], 
209            user_market_states: list[UserMarketState],
210            aver_markets: list[AverMarket],
211            user_balance_states: list[UserBalanceState],
212            user_host_lifetime_states: list[UserHostLifetimeState],
213            user_host_lifetime_pubkeys: list[PublicKey]
214        ):
215        """
216        Returns multiple UserMarket objects from their respective MarketStates, stores and orderbook objects
217
218        Used in refresh.py
219
220        Args:
221            aver_client (AverClient): AverClient object
222            pubkeys (list[PublicKey]): List of UserMarket account pubkeys
223            user_market_states (list[UserMarketState]): List of UserMarketState objects
224            aver_markets (list[AverMarket]): List of AverMarket objects
225            user_balance_states (list[UserBalanceState]): List of UserBalanceState objects
226            user_host_lifetime_states: (List[UserHostLifetimeState]): List of UserHostLifetimeState objects
227            user_host_lifetime_pubkeys (list[PublicKey]): List of UserHostLifetime public keys
228
229        Returns:
230            list[UserMarket]: List of UserMarket objects
231        """
232        user_markets: list[UserMarket] = []
233        for i, pubkey in enumerate(pubkeys):
234            user_market = UserMarket(aver_client, pubkey, user_market_states[i], aver_markets[i], user_balance_states[i], UserHostLifetime(user_host_lifetime_pubkeys[i],user_host_lifetime_states[i]))
235            user_markets.append(user_market)
236        return user_markets
237    
238    
239    @staticmethod
240    def parse_multiple_user_market_state(
241            buffer: list[bytes],
242            aver_client: AverMarket
243        ):
244        """
245        Parses raw onchain data to UserMarketState objects    
246
247        Args:
248            buffer (list[bytes]): List of raw bytes coming from onchain
249            aver_client (AverMarket): AverClient object
250
251        Returns:
252            list[UserMarketState]: List of UserMarketState objects
253        """
254        return [parse_user_market_state(b, aver_client) for b in buffer]
255
256    @staticmethod
257    def derive_pubkey_and_bump(
258            owner: PublicKey,
259            market: PublicKey,
260            host: PublicKey,
261            program_id: PublicKey = AVER_PROGRAM_ID
262        ) -> PublicKey:
263        """
264        Derives PDA (Program Derived Account) for UserMarket public key given a user, host and market
265
266        Args:
267            owner (PublicKey): Owner of UserMarket account
268            market (PublicKey): Corresponding Market account public key
269            host (PublicKey): Host public key
270            program_id (PublicKey, optional): _description_. Defaults to AVER_PROGRAM_ID.
271
272        Returns:
273            PublicKey: UserMarket account public key
274        """
275
276        return PublicKey.find_program_address(
277            [bytes('user-market', 'utf-8'), bytes(owner), bytes(market), bytes(host)],
278            program_id
279        )    
280
281    @staticmethod
282    def make_create_user_market_account_instruction(
283            aver_client: AverClient,
284            market: AverMarket,
285            owner: PublicKey,
286            host: PublicKey = AVER_HOST_ACCOUNT, 
287            number_of_orders: int = None,
288            program_id: PublicKey = AVER_PROGRAM_ID
289        ):
290        """
291        Creates instruction for UserMarket account creation
292
293        Returns TransactionInstruction object only. Does not send transaction.
294
295        Args:
296            aver_client (AverClient): AverClient object
297            market (AverMarket): Corresponding Market object
298            owner (PublicKey): Owner of UserMarket account
299            host (PublicKey, optional): Host account public key. Defaults to AVER_HOST_ACCOUNT.
300            number_of_orders (int, optional): _description_. Defaults to 5*number of market outcomes.
301            program_id (PublicKey, optional): Program public key. Defaults to AVER_PROGRAM_ID.
302
303        Returns:
304            TransactionInstruction: TransactionInstruction object
305        """
306        if(number_of_orders is None):
307            number_of_orders = market.market_state.number_of_outcomes * 5
308        
309        uma, uma_bump = UserMarket.derive_pubkey_and_bump(owner, market.market_pubkey, host, program_id)
310        user_host_lifetime, uhl_bump = UserHostLifetime.derive_pubkey_and_bump(owner, host, program_id)
311
312        return aver_client.program.instruction['init_user_market'](
313            number_of_orders,
314            uma_bump, 
315            ctx=Context(
316                accounts={
317                    "user": owner,
318                    "user_host_lifetime": user_host_lifetime,
319                    "user_market": uma,
320                    "market": market.market_pubkey,
321                    "host": host,
322                    "system_program": SYS_PROGRAM_ID,
323                },
324            )
325        )
326
327    @staticmethod
328    async def create_user_market_account(
329            aver_client: AverClient,
330            market: AverMarket,
331            owner: Keypair = None,
332            send_options: TxOpts = None,
333            host: PublicKey = AVER_HOST_ACCOUNT,
334            number_of_orders: int = None,
335            program_id: PublicKey = AVER_PROGRAM_ID
336        ):
337        """
338        Creates UserMarket account
339
340        Sends instructions on chain
341
342        Args:
343            aver_client (AverClient): AverClient object
344            market (AverMarket): Correspondign Market object
345            owner (Keypair): Owner of UserMarket account. Defaults to AverClient wallet
346            send_options (TxOpts, optional): Options to specify when broadcasting a transaction. Defaults to None.
347            host (PublicKey, optional): Host account public key. Defaults to AVER_HOST_ACCOUNT.
348            number_of_orders (int, optional): _description_. Defaults to 5 * number of market outcomes.
349            program_id (PublicKey, optional): Program public key. Defaults to AVER_PROGRAM_ID.
350
351        Returns:
352            RPCResponse: Response
353        """
354        if(number_of_orders is None):
355            number_of_orders = 5 * market.market_state.number_of_outcomes
356
357        if(owner is None):
358            owner = aver_client.owner
359
360        ix = UserMarket.make_create_user_market_account_instruction(
361            aver_client,
362            market,
363            owner.public_key,
364            host,
365            number_of_orders,
366            program_id
367        )
368
369        if(send_options is None):
370            send_options = TxOpts()
371        else:
372            send_options = TxOpts(
373                skip_confirmation=send_options.skip_confirmation,
374                skip_preflight=send_options.skip_confirmation,
375                preflight_commitment=Finalized,
376                max_retries=send_options.max_retries)
377
378        return await sign_and_send_transaction_instructions(
379            aver_client,
380            [],
381            owner,
382            [ix],
383            send_options,
384        )
385    
386    @staticmethod
387    async def get_or_create_user_market_account(
388            client: AverClient,
389            market: AverMarket,
390            owner: Keypair = None,
391            send_options: TxOpts = None,
392            quote_token_mint: PublicKey = None,
393            host: PublicKey = AVER_HOST_ACCOUNT,
394            number_of_orders: int = None,
395            referrer: PublicKey = SYS_PROGRAM_ID,
396            discount_token: PublicKey = SYS_PROGRAM_ID,
397            program_id: PublicKey = AVER_PROGRAM_ID 
398        ):
399        """
400        Attempts to load UserMarket object or creates one if not one is not found
401
402        Args:
403            client (AverClient): AverClient object
404            market (AverMarket): Corresponding AverMarket object
405            owner (Keypair): Owner of UserMarket account. Defaults to AverClient wallet
406            send_options (TxOpts, optional): Options to specify when broadcasting a transaction. Defaults to None.
407            quote_token_mint (PublicKey, optional): ATA token mint public key. Defaults to USDC token according to chosen solana network.
408            host (PublicKey, optional): Host account public key. Defaults to AVER_HOST_ACCOUNT.
409            number_of_orders (int, optional): _description_. Defaults to 5 * number of market outcomes.
410            referrer (PublicKey, optional): Referrer account public key. Defaults to SYS_PROGRAM_ID.
411            discount_token (PublicKey, optional): _description_. Defaults to SYS_PROGRAM_ID.
412            program_id (PublicKey, optional): Program public key. Defaults to AVER_PROGRAM_ID.
413
414        Returns:
415            UserMarket: UserMarket object
416        """
417        quote_token_mint = quote_token_mint if quote_token_mint is not None else client.quote_token
418        if(number_of_orders is None):
419            number_of_orders = market.market_state.number_of_outcomes * 5
420        
421        if(owner is None):
422            owner = client.owner
423        
424        user_market_pubkey = UserMarket.derive_pubkey_and_bump(owner.public_key, market.market_pubkey, host, program_id)[0]
425        try:
426            uma = await UserMarket.load(client, market, owner.public_key, host, program_id)
427            return uma
428        except:
429            uhl = await UserHostLifetime.get_or_create_user_host_lifetime(
430                client,
431                owner,
432                send_options,
433                quote_token_mint,
434                host,
435                referrer,
436                discount_token,
437                program_id
438            )
439
440            sig = await UserMarket.create_user_market_account(
441                client,
442                market,
443                owner, 
444                send_options,
445                host,
446                number_of_orders,
447                program_id,
448            )
449
450            await client.provider.connection.confirm_transaction(
451                sig['result'],
452                commitment=Finalized
453            )
454
455            return await UserMarket.load(
456                client, 
457                market,  
458                owner.public_key,
459                host,
460                program_id)
461
462
463
464    def make_place_order_instruction(
465            self,
466            outcome_id: int,
467            side: Side,
468            limit_price: float,
469            size: float,
470            size_format: SizeFormat,
471            user_quote_token_ata: PublicKey,
472            order_type: OrderType = OrderType.LIMIT,
473            self_trade_behavior: SelfTradeBehavior = SelfTradeBehavior.CANCEL_PROVIDE,
474            active_pre_flight_check: bool = False,
475        ):
476        """
477        Creates instruction to place order.
478
479        Returns TransactionInstruction object only. Does not send transaction.
480
481        Args:
482            outcome_id (int): ID of outcome
483            side (Side): Side object (bid or ask)
484            limit_price (float): Limit price - in probability format i.e. in the range (0, 1). If you are using Decimal or other odds formats you will need to convert these prior to passing as an argument
485            size (float): Size - in the format specified in size_format. This value is in number of 'tokens' - i.e. 20.45 => 20.45 USDC, the SDK handles the conversion to u64 token units (e.g. to 20,450,000 as USDC is a 6 decimal place token)
486            size_format (SizeFormat): SizeFormat object (Stake or Payout)
487            user_quote_token_ata (PublicKey): Quote token ATA public key (holds funds for this user)
488            order_type (OrderType, optional): OrderType object. Defaults to OrderType.LIMIT.
489            self_trade_behavior (SelfTradeBehavior, optional): Behavior when a user's trade is matched with themselves. Defaults to SelfTradeBehavior.CANCEL_PROVIDE.
490            active_pre_flight_check (bool, optional): Clientside check if order will success or fail. Defaults to False.
491
492        Raises:
493            Exception: Cannot place error on closed market
494
495        Returns:
496            TransactionInstruction: TransactionInstruction object
497        """
498        if(self.market.orderbooks is None):
499            raise Exception('Cannot place error on closed market')
500
501        if(active_pre_flight_check):
502            check_sufficient_lamport_balance(self.user_balance_state)
503            check_correct_uma_market_match(self.user_market_state, self.market)
504            check_market_active_pre_event(self.market.market_state.market_status)
505            check_uhl_self_excluded(self.user_host_lifetime)
506            check_user_market_full(self.user_market_state)
507            check_limit_price_error(limit_price, self.market)
508            check_outcome_outside_space(outcome_id, self.market)
509            check_incorrect_order_type_for_market_order(limit_price, order_type, side, self.market)
510            check_stake_noop(size_format, limit_price, side)
511            tokens_available_to_buy = self.calculate_tokens_available_to_buy(outcome_id, limit_price)
512            tokens_available_to_sell = self.calculate_tokens_available_to_sell(outcome_id, limit_price)
513            check_is_order_valid(outcome_id, side, limit_price, size, size_format, tokens_available_to_sell, tokens_available_to_buy)
514            check_quote_and_base_size_too_small(self.market, side, size_format, outcome_id, limit_price, size)
515            check_user_permission_and_quote_token_limit_exceeded(self.market, self.user_market_state, size, limit_price, size_format)
516        
517        max_base_qty = math.floor(size * (10 ** self.market.market_state.decimals))
518        limit_price_u64 = math.ceil(limit_price * (10 ** self.market.market_state.decimals))
519
520        is_binary_market_second_outcome = self.market.market_state.number_of_outcomes == 2 and outcome_id == 1
521        orderbook_account_index = outcome_id if not is_binary_market_second_outcome else 0
522        orderbook_account = self.market.market_store_state.orderbook_accounts[orderbook_account_index]
523
524        return self.aver_client.program.instruction['place_order'](
525            {
526                "limit_price": limit_price_u64,
527                "size": max_base_qty,
528                "size_format": size_format,
529                "side": side,
530                "order_type": order_type,
531                "self_trade_behavior": self_trade_behavior,
532                "outcome_id": outcome_id,
533            },
534            ctx=Context(
535                accounts={
536                    "user": self.user_market_state.user,
537                    "user_host_lifetime": self.user_market_state.user_host_lifetime,
538                    "market": self.market.market_pubkey,
539                    "market_store": self.market.market_state.market_store,
540                    "user_market": self.pubkey,
541                    "user": self.user_market_state.user,
542                    "user_quote_token_ata": user_quote_token_ata,
543                    "quote_vault": self.market.market_state.quote_vault,
544                    "orderbook": orderbook_account.orderbook,
545                    "bids": orderbook_account.bids,
546                    "asks": orderbook_account.asks,
547                    "event_queue": orderbook_account.event_queue,
548                    "spl_token_program": TOKEN_PROGRAM_ID,
549                    "system_program": SYS_PROGRAM_ID,
550               },)
551        )
552
553    async def place_order(
554            self,
555            owner: Keypair,
556            outcome_id: int,
557            side: Side,
558            limit_price: float,
559            size: float,
560            size_format: SizeFormat,
561            send_options: TxOpts = None,
562            order_type: OrderType = OrderType.LIMIT,
563            self_trade_behavior: SelfTradeBehavior = SelfTradeBehavior.CANCEL_PROVIDE,
564            active_pre_flight_check: bool = True,  
565        ):
566        """
567        Places a new order
568
569        Sends instructions on chain
570
571        Args:
572            owner (Keypair): Owner of UserMarket account. Pays transaction fees.
573            outcome_id (int): index of the outcome intended to be traded
574            side (Side): Side object (bid/back/buy or ask/lay/sell)
575            limit_price (float): Limit price - in probability format i.e. in the range (0, 1). If you are using Decimal or other odds formats you will need to convert these prior to passing as an argument
576            size (float): Size - in the format specified in size_format. This value is in number of 'tokens' - i.e. 20.45 => 20.45 USDC, the SDK handles the conversion to u64 token units (e.g. to 20,450,000 as USDC is a 6 decimal place token)
577            size_format (SizeFormat): SizeFormat object (Stake or Payout formats supported)
578            send_options (TxOpts, optional): Options to specify when broadcasting a transaction. Defaults to None.
579            order_type (OrderType, optional): OrderType object. Defaults to OrderType.LIMIT. Other options include OrderType.IOC, OrderType.KILL_OR_FILL, OrderType.POST_ONLY.
580            self_trade_behavior (SelfTradeBehavior, optional): Behavior when a user's trade is matched with themselves. Defaults to SelfTradeBehavior.CANCEL_PROVIDE. Other options include SelfTradeBehavior.DECREMENT_TAKE and SelfTradeBehavior.ABORT_TRANSACTION.
581            active_pre_flight_check (bool, optional): Clientside check if order will success or fail. Defaults to True. 
582
583        Raises:
584            Exception: Owner must be same as user market owner
585
586        Returns:
587            RPCResponse: Response
588        """
589        if(not owner.public_key == self.user_market_state.user):
590            raise Exception('Owner must be same as user market owner')
591
592        user_quote_token_ata = await self.market.aver_client.get_or_create_associated_token_account(
593            self.user_market_state.user,
594            self.market.aver_client.owner,
595            self.market.market_state.quote_token_mint
596        )
597
598        ix = self.make_place_order_instruction(
599            outcome_id,
600            side, 
601            limit_price,
602            size,
603            size_format,
604            user_quote_token_ata,
605            order_type,
606            self_trade_behavior,
607            active_pre_flight_check
608        )
609        return await sign_and_send_transaction_instructions(
610            self.aver_client,
611            [],
612            owner,
613            [ix],
614            send_options
615        )
616
617    def make_cancel_order_instruction(
618            self,
619            order_id: int,
620            outcome_id: int,
621            active_pre_flight_check: bool = False,
622        ):
623        """
624        Creates instruction for to cancel order.
625
626        Returns TransactionInstruction object only. Does not send transaction.
627
628        Args:
629            order_id (int): ID of order to cancel
630            outcome_id (int): ID of outcome
631            active_pre_flight_check (bool, optional): Clientside check if order will success or fail. Defaults to False.
632
633        Raises:
634            Exception: Cannot cancel orders on closed market
635            Exception: Insufficient lamport balance
636            Exception: Cannot cancel orders in current market status
637            Exception: Order ID does not exist in list of open orders
638
639        Returns:
640            TransactionInstruction: TransactionInstruction object
641        """
642        if(self.market.orderbooks is None):
643            raise Exception('Cannot cancel orders on closed market')
644
645        if(active_pre_flight_check):
646            check_sufficient_lamport_balance(self.user_balance_state)
647            check_cancel_order_market_status(self.market.market_state.market_status)
648            check_order_exists(self.user_market_state, order_id)
649      
650        is_binary_market_second_outcome = self.market.market_state.number_of_outcomes == 2 and outcome_id == 1
651        orderbook_account_index = outcome_id if not is_binary_market_second_outcome else 0
652        orderbook_account = self.market.market_store_state.orderbook_accounts[orderbook_account_index]
653
654        return self.aver_client.program.instruction['cancel_order'](
655            order_id, 
656            orderbook_account_index, 
657            ctx=Context(accounts={
658                "orderbook": orderbook_account.orderbook,
659                "event_queue": orderbook_account.event_queue,
660                "bids": orderbook_account.bids,
661                "asks": orderbook_account.asks,
662                "market": self.market.market_pubkey,
663                "user_market": self.pubkey,
664                "user": self.user_market_state.user,
665                "market_store": self.market.market_state.market_store,
666            })
667        )
668    
669    async def cancel_order(
670        self,
671        order_id: int,
672        outcome_id: int,
673        fee_payer: Keypair = None,
674        send_options: TxOpts = None,
675        active_pre_flight_check: bool = True,
676    ):
677        """
678        Cancels order
679
680        Sends instructions on chain
681
682        Args:
683            fee_payer (Keypair): Keypair to pay fee for transaction. Defaults to AverClient wallet
684            order_id (int): ID of order to cancel
685            outcome_id (int): ID of outcome
686            send_options (TxOpts, optional): Options to specify when broadcasting a transaction. Defaults to None.
687            active_pre_flight_check (bool, optional): Clientside check if order will success or fail. Defaults to True.
688
689        Returns:
690            RPCResponse: Response
691        """
692
693        if(fee_payer is None):
694            fee_payer = self.aver_client.owner
695
696        ix = self.make_cancel_order_instruction(
697            order_id,
698            outcome_id,
699            active_pre_flight_check
700        )
701
702        return await sign_and_send_transaction_instructions(
703            self.aver_client,
704            [],
705            fee_payer,
706            [ix],
707            send_options
708        )
709
710    def make_cancel_all_orders_instruction(
711        self, 
712        outcome_ids_to_cancel: list[int],
713        active_pre_flight_check: bool = False,
714        ):
715        """
716        Creates instruction for to cancelling all orders
717
718        Cancels all orders on particular outcome_ids (not by order_id)
719
720        Returns TransactionInstruction object only. Does not send transaction.
721
722        Args:
723            outcome_ids_to_cancel (list[int]): List of outcome ids to cancel orders on
724            active_pre_flight_check (bool, optional): Clientside check if order will success or fail. Defaults to False.
725
726        Raises:
727            Exception: Cannot cancel orders on closed market
728            Exception: Insufficient lamport balance
729            Exception: Cannot cancel orders in current market status
730
731        Returns:
732            TransactionInstruction: TransactionInstruction object
733        """
734        if(self.market.orderbooks is None):
735            raise Exception('Cannot cancel orders on closed market')
736
737        if(active_pre_flight_check):
738            check_sufficient_lamport_balance(self.user_balance_state)
739            check_cancel_order_market_status(self.market.market_state.market_status)
740            for outcome_id in outcome_ids_to_cancel:
741                check_outcome_has_orders(outcome_id, self.user_market_state)
742
743        remaining_accounts: list[AccountMeta] = []
744        for i, accounts in enumerate(self.market.market_store_state.orderbook_accounts):
745            if(not outcome_ids_to_cancel.__contains__(i)):
746                continue
747            remaining_accounts += [AccountMeta(
748                pubkey=accounts.orderbook,
749                is_signer=False,
750                is_writable=True,
751            )]
752            remaining_accounts += [AccountMeta(
753                pubkey=accounts.event_queue,
754                is_signer=False,
755                is_writable=True,
756            )]
757            remaining_accounts += [AccountMeta(
758                pubkey=accounts.bids,
759                is_signer=False,
760                is_writable=True,
761            )]
762            remaining_accounts += [AccountMeta(
763                pubkey=accounts.asks,
764                is_signer=False,
765                is_writable=True,
766            )]
767        
768        chunk_size = CANCEL_ALL_ORDERS_INSTRUCTION_CHUNK_SIZE
769        chunked_outcome_ids = chunk(outcome_ids_to_cancel, chunk_size)
770        chunked_remaining_accounts = chunk(remaining_accounts, chunk_size * 4)
771
772        ixs = []
773
774        for i, outcome_ids in enumerate(chunked_outcome_ids):
775            ixs.append(
776                self.aver_client.program.instruction['cancel_all_orders'](
777                    outcome_ids,
778                    ctx=Context(
779                        accounts={
780                                "user_market": self.pubkey,
781                                "market": self.market.market_pubkey,
782                                "user": self.user_market_state.user,
783                                "market_store": self.market.market_state.market_store,
784                            },
785                        remaining_accounts = chunked_remaining_accounts[i],
786                        )
787                    )
788            )
789
790        return ixs
791    
792    async def cancel_all_orders(
793        self,
794        outcome_ids_to_cancel: list[int], 
795        fee_payer: Keypair = None, 
796        send_options: TxOpts = None,
797        active_pre_flight_check: bool = True,
798    ):
799        """
800        Cancels all orders on particular outcome_ids (not by order_id)
801
802        Sends instructions on chain
803
804        Args:
805            fee_payer (Keypair): Keypair to pay fee for transaction. Defaults to AverClient wallet
806            outcome_ids_to_cancel (list[int]): List of outcome ids to cancel orders on
807            send_options (TxOpts, optional): Options to specify when broadcasting a transaction. Defaults to None.
808            active_pre_flight_check (bool, optional): Clientside check if order will success or fail. Defaults to True.
809
810        Returns:
811            RPCResponse: Response
812        """
813        if(fee_payer is None):
814            fee_payer = self.aver_client.owner
815        
816        ixs = self.make_cancel_all_orders_instruction(outcome_ids_to_cancel, active_pre_flight_check)
817
818        sigs = await gather(
819            *[sign_and_send_transaction_instructions(
820                self.aver_client,
821                [],
822                fee_payer,
823                [ix],
824                send_options
825            ) for ix in ixs]
826            )
827        return sigs
828
829    def make_withdraw_idle_funds_instruction(
830        self,
831        user_quote_token_ata: PublicKey,
832        amount: float = None,
833    ):
834        """
835        Creates instruction for withdrawing funds in ATA 
836
837        Returns TransactionInstruction object only. Does not send transaction.
838
839        Args:
840            user_quote_token_ata (PublicKey): Quote token ATA public key (holds funds for this user)
841            amount (float, optional): amount. Defaults to maximum available funds.
842
843        Returns:
844            TransactionInstruction: TransactionInstruction object
845        """
846        if(amount is None):
847            amount = self.calculate_funds_available_to_withdraw()
848        
849        return self.aver_client.program.instruction['withdraw_tokens'](
850            amount,
851            ctx=Context(
852                accounts={
853                    "market": self.market.market_pubkey,
854                    "user_market": self.pubkey,
855                    "user": self.user_market_state.user,
856                    "user_quote_token_ata": user_quote_token_ata,
857                    "quote_vault": self.market.market_state.quote_vault,
858                    "vault_authority": self.market.market_state.vault_authority,
859                    "spl_token_program": TOKEN_PROGRAM_ID,
860                },
861            )
862        )
863    
864    async def withdraw_idle_funds(self, owner: Keypair, send_options: TxOpts = None, amount: float = None):
865        """
866        Withdraws idle funds in ATA
867
868        Sends instructions on chain
869
870        Args:
871            owner (Keypair): Owner of UserMarket account
872            send_options (TxOpts, optional): Options to specify when broadcasting a transaction. Defaults to None.
873            amount (float, optional): amount. Defaults to None.
874
875        Raises:
876            Exception: Owner must be same as UMA owner
877
878        Returns:
879            TransactionInstruction: TransactionInstruction object
880        """
881        user_quote_token_ata = await self.market.aver_client.get_or_create_associated_token_account(
882            self.user_market_state.user,
883            self.market.aver_client.owner,
884            self.market.market_state.quote_token_mint
885        )
886        
887        ix = self.make_withdraw_idle_funds_instruction(user_quote_token_ata, amount)
888
889        if(not owner.public_key == self.user_market_state.user):
890            raise Exception('Owner must be same as UMA owner')
891
892        return await sign_and_send_transaction_instructions(
893            self.aver_client,
894            [],
895            owner,
896            [ix],
897            send_options
898        )
899
900
901    def calculate_funds_available_to_withdraw(self):
902        """
903        Calculates idle funds available to withdraw
904
905        Returns:
906            int: Tokens available to withdraw
907        """
908        return min([o.free for o in self.user_market_state.outcome_positions] + [self.user_market_state.net_quote_tokens_in])
909
910    def calculate_funds_available_to_collect(self, winning_outcome: int):
911        """
912        Calculate funds won if a particular outcome wins
913
914        Args:
915            winning_outcome (int): Winning outcome ID
916
917        Returns:
918            int: Tokens won
919        """
920        winning_outcome_position = self.user_market_state.outcome_positions[winning_outcome]
921        return winning_outcome_position.free + winning_outcome_position.locked
922
923    def calculate_exposures(self):
924        """
925        Calcualtes exposures for every possible outcome
926
927        The exposure on a particular outcome is the profit/loss if that outcome wins
928
929        Returns:
930            list[int]: List of exposures
931        """
932        net_quote_tokens_in = self.user_market_state.net_quote_tokens_in
933        return [o.free + o.locked - net_quote_tokens_in for o in self.user_market_state.outcome_positions]
934
935
936
937    def calculate_tokens_available_to_sell(self, outcome_index: int, price: float):
938        """
939        Calculates tokens available to sell on a particular outcome
940
941        Args:
942            outcome_index (int): Outcome ID
943            price (float): Price - in probability format i.e. in the range (0, 1). If you are using Decimal or other odds formats you will need to convert these prior to passing as an argument
944
945        Returns:
946            float: Token amount
947        """
948        return self.user_market_state.outcome_positions[outcome_index].free + price * self.user_balance_state.token_balance
949    
950    def calculate_tokens_available_to_buy(self, outcome_index: int, price: float):
951        """
952         Calculates tokens available to buy on a particular outcome
953
954        Args:
955            outcome_index (int): Outcome ID
956            price (float): Price - in probability format i.e. in the range (0, 1). If you are using Decimal or other odds formats you will need to convert these prior to passing as an argument
957
958        Returns:
959            float: Token amount
960        """
961        filtered_outcomes = deepcopy(self.user_market_state.outcome_positions)
962        del filtered_outcomes[outcome_index]
963        min_free_tokens_except_outcome_index  = min([op.free for op in filtered_outcomes])
964
965        return min_free_tokens_except_outcome_index + price * self.user_balance_state.token_balance
966    
967    def calculate_min_free_outcome_positions(self):
968        return min([o.free for o in self.user_market_state.outcome_positions])