pyaver.refresh

  1from .aver_client import AverClient
  2from .user_market import AverMarket, UserMarket
  3from .utils import load_multiple_account_states
  4
  5
  6
  7"""
  8Use this function to quickly refresh market data (it is quicker that AverMarket.load_multiple)
  9"""
 10async def refresh_multiple_markets(
 11    aver_client: AverClient, 
 12    markets: list[AverMarket],
 13    ) -> list[AverMarket]:
 14    """
 15    Refresh all data for multiple markets quickly
 16
 17    This function optimizes the calls to the Solana network batching them efficiently so that many can be reloaded in the fewest calls.
 18
 19    Use instead instead of src.market.AverMarket.load_multiple()
 20
 21    Args:
 22        aver_client (AverClient): AverClient object
 23        markets (list[AverMarket]): List of AverMarket objects
 24
 25    Returns:
 26        list[AverMarket]: List of refreshed AverMarket objects
 27    """
 28    market_pubkeys = [m.market_pubkey for m in markets]
 29    market_store_pubkeys = [m.market_state.market_store for m in markets]
 30
 31    slabs_pubkeys = []
 32    for m in markets:
 33        if(m.market_store_state is None or m.market_store_state.orderbook_accounts is None):
 34            continue
 35        oa = m.market_store_state.orderbook_accounts
 36        for s in oa:
 37            slabs_pubkeys.append(s.bids)
 38            slabs_pubkeys.append(s.asks)
 39    
 40    multiple_account_states = await load_multiple_account_states(
 41        aver_client, 
 42        market_pubkeys,
 43        market_store_pubkeys,
 44        slabs_pubkeys,
 45        )
 46
 47    markets = AverMarket.get_markets_from_account_states(
 48        aver_client, 
 49        market_pubkeys, 
 50        multiple_account_states['market_states'], 
 51        multiple_account_states['market_stores'], 
 52        multiple_account_states['slabs'],
 53    )
 54
 55    return markets
 56
 57async def refresh_market(aver_client: AverClient, market: AverMarket) -> AverMarket:
 58    """
 59    Refresh all data for an AverMarket quickly
 60
 61    This function optimizes the calls to the Solana network batching them efficiently so that many can be reloaded in the fewest calls.
 62
 63    Use instead instead of src.market.AverMarket.load()
 64
 65    Args:
 66        aver_client (AverClient): AverClient object
 67        market (AverMarket): AverMarket object
 68
 69    Returns:
 70        AverMarket: Refreshed AverMarket object
 71    """
 72    return (await refresh_multiple_markets(aver_client, [market]))[0]
 73
 74async def refresh_multiple_user_markets(
 75    aver_client: AverClient, 
 76    user_markets: list[UserMarket],
 77    ) -> list[UserMarket]:
 78    """
 79    Refresh all data for multiple user markets quickly
 80
 81    This function optimizes the calls to the Solana network batching them efficiently so that many can be reloaded in the fewest calls.
 82
 83    Also refreshes the underlying AverMarket objects
 84
 85    Args:
 86        aver_client (AverClient): AverMarket object
 87        user_markets (list[UserMarket]): List of UserMarket objects
 88
 89    Returns:
 90        list[UserMarket]: List of refreshed UserMarket objects
 91    """
 92    market_pubkeys = [u.market.market_pubkey for u in user_markets]
 93    market_store_pubkeys = [u.market.market_state.market_store for u in user_markets]
 94    user_markets_pubkeys = [u.pubkey for u in user_markets]
 95    user_pubkeys = [u.user_market_state.user for u in user_markets]
 96    uhl_pubkeys = [u.user_host_lifetime.pubkey for u in user_markets]
 97
 98    slabs_pubkeys = []
 99    for u in user_markets:
100        if(u.market.market_store_state is None or u.market.market_store_state.orderbook_accounts is None):
101            continue
102        oa = u.market.market_store_state.orderbook_accounts
103        for s in oa:
104            slabs_pubkeys.append(s.bids)
105            slabs_pubkeys.append(s.asks)
106    
107    multiple_account_states = await load_multiple_account_states(
108        aver_client, 
109        market_pubkeys,
110        market_store_pubkeys,
111        slabs_pubkeys,
112        user_markets_pubkeys,
113        user_pubkeys,
114        uhl_pubkeys
115        )
116
117    markets = AverMarket.get_markets_from_account_states(
118        aver_client, 
119        market_pubkeys, 
120        multiple_account_states['market_states'], 
121        multiple_account_states['market_stores'], 
122        multiple_account_states['slabs'],
123    )
124
125    user_markets = UserMarket.get_user_markets_from_account_state(
126        aver_client,
127        user_markets_pubkeys,
128        multiple_account_states['user_market_states'],
129        markets,
130        multiple_account_states['user_balance_states'],
131        multiple_account_states['user_host_lifetime_states'],
132        uhl_pubkeys
133    )
134    
135    return user_markets
136
137async def refresh_user_market(aver_client: AverClient, user_market: UserMarket) -> UserMarket:
138    """
139    Refresh all data for a user markets quickly
140
141    This function optimizes the calls to the Solana network batching them efficiently so that many can be reloaded in the fewest calls.
142
143    Also refreshes the underlying AverMarket object
144
145    Args:
146        aver_client (AverClient): AverClient object
147        user_market (UserMarket): UserMarket object
148
149    Returns:
150        UserMarket: Refreshed UserMarket object
151    """
152    return (await refresh_multiple_user_markets(aver_client, [user_market]))[0]