polymarket-apis 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

polymarket_apis/clients/graphql_client.py

@@ -5,7 +5,13 @@ from gql.transport.httpx import HTTPXAsyncTransport, HTTPXTransport
 
 from ..utilities.config import GRAPHQL_ENDPOINTS
 
-EndpointName = Literal[
+
+class PolymarketGraphQLClient:
+    """Synchronous GraphQL client for Polymarket subgraphs."""
+
+    def __init__(
+        self,
+        endpoint_name: Literal[
             "activity_subgraph",
             "fpmm_subgraph",
             "open_interest_subgraph",
@@ -14,16 +20,13 @@ EndpointName = Literal[
             "positions_subgraph",
             "sports_oracle_subgraph",
             "wallet_subgraph",
-            ]
-
-
-class PolymarketGraphQLClient:
-    """Synchronous GraphQL client for Polymarket subgraphs."""
-
-    def __init__(self, endpoint_name: EndpointName) -> None:
+        ],
+    ) -> None:
         endpoint_url = GRAPHQL_ENDPOINTS[endpoint_name]
         self.transport = HTTPXTransport(url=endpoint_url)
-        self.client = Client(transport=self.transport, fetch_schema_from_transport=False)
+        self.client = Client(
+            transport=self.transport, fetch_schema_from_transport=False
+        )
 
     def query(self, query_string: str) -> dict:
         with self.client as session:
@@ -33,10 +36,24 @@ class PolymarketGraphQLClient:
 class AsyncPolymarketGraphQLClient:
     """Asynchronous GraphQL client for Polymarket subgraphs."""
 
-    def __init__(self, endpoint_name: EndpointName) -> None:
+    def __init__(
+        self,
+        endpoint_name: Literal[
+            "activity_subgraph",
+            "fpmm_subgraph",
+            "open_interest_subgraph",
+            "orderbook_subgraph",
+            "pnl_subgraph",
+            "positions_subgraph",
+            "sports_oracle_subgraph",
+            "wallet_subgraph",
+        ],
+    ) -> None:
         endpoint_url = GRAPHQL_ENDPOINTS[endpoint_name]
         self.transport = HTTPXAsyncTransport(url=endpoint_url)
-        self.client = Client(transport=self.transport, fetch_schema_from_transport=False)
+        self.client = Client(
+            transport=self.transport, fetch_schema_from_transport=False
+        )
 
     async def query(self, query_string: str) -> dict:
         async with self.client as session:

polymarket_apis/clients/web3_client.py

@@ -14,16 +14,24 @@ from ..utilities.web3.helpers import get_index_set
 
 
 def _load_abi(contract_name: str) -> list:
-    abi_path = Path(__file__).parent.parent/"utilities"/"web3"/"abis"/f"{contract_name}.json"
+    abi_path = (
+        Path(__file__).parent.parent
+        / "utilities"
+        / "web3"
+        / "abis"
+        / f"{contract_name}.json"
+    )
     with Path.open(abi_path) as f:
         return load(f)
 
-class PolymarketWeb3Client:
-    def __init__(self, private_key: str , chain_id: Literal[137, 80002] = POLYGON):
 
+class PolymarketWeb3Client:
+    def __init__(self, private_key: str, chain_id: Literal[137, 80002] = POLYGON):
         self.w3 = Web3(Web3.HTTPProvider("https://polygon-rpc.com"))
         self.w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
-        self.w3.middleware_onion.inject(SignAndSendRawMiddlewareBuilder.build(private_key), layer=0)
+        self.w3.middleware_onion.inject(
+            SignAndSendRawMiddlewareBuilder.build(private_key), layer=0
+        )
 
         self.account = self.w3.eth.account.from_key(private_key)
 
@@ -34,25 +42,37 @@ class PolymarketWeb3Client:
         self.usdc_abi = _load_abi("UChildERC20Proxy")
         self.usdc = self.contract(self.usdc_address, self.usdc_abi)
 
-        self.conditional_tokens_address = Web3.to_checksum_address(self.config.conditional_tokens)
+        self.conditional_tokens_address = Web3.to_checksum_address(
+            self.config.conditional_tokens
+        )
         self.conditional_tokens_abi = _load_abi("ConditionalTokens")
-        self.conditional_tokens = self.contract(self.conditional_tokens_address, self.conditional_tokens_abi)
+        self.conditional_tokens = self.contract(
+            self.conditional_tokens_address, self.conditional_tokens_abi
+        )
 
         self.exchange_address = Web3.to_checksum_address(self.config.exchange)
         self.exchange_abi = _load_abi("CTFExchange")
         self.exchange = self.contract(self.exchange_address, self.exchange_abi)
 
-        self.neg_risk_exchange_address = Web3.to_checksum_address(self.neg_risk_config.exchange)
+        self.neg_risk_exchange_address = Web3.to_checksum_address(
+            self.neg_risk_config.exchange
+        )
         self.neg_risk_exchange_abi = _load_abi("NegRiskCtfExchange")
-        self.neg_risk_exchange = self.contract(self.neg_risk_exchange_address, self.neg_risk_exchange_abi)
+        self.neg_risk_exchange = self.contract(
+            self.neg_risk_exchange_address, self.neg_risk_exchange_abi
+        )
 
         self.neg_risk_adapter_address = "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
         self.neg_risk_adapter_abi = _load_abi("NegRiskAdapter")
-        self.neg_risk_adapter = self.contract(self.neg_risk_adapter_address, self.neg_risk_adapter_abi)
+        self.neg_risk_adapter = self.contract(
+            self.neg_risk_adapter_address, self.neg_risk_adapter_abi
+        )
 
         self.proxy_factory_address = "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052"
         self.proxy_factory_abi = _load_abi("ProxyWalletFactory")
-        self.proxy_factory = self.contract(self.proxy_factory_address, self.proxy_factory_abi)
+        self.proxy_factory = self.contract(
+            self.proxy_factory_address, self.proxy_factory_abi
+        )
 
     def _encode_split(self, condition_id: Keccak256, amount: int) -> str:
         return self.conditional_tokens.encode_abi(
@@ -72,12 +92,17 @@ class PolymarketWeb3Client:
             args=[self.usdc_address, HASH_ZERO, condition_id, [1, 2]],
         )
 
-    def _encode_redeem_neg_risk(self, condition_id: Keccak256, amounts: list[int]) -> str:
+    def _encode_redeem_neg_risk(
+        self, condition_id: Keccak256, amounts: list[int]
+    ) -> str:
         return self.neg_risk_adapter.encode_abi(
             abi_element_identifier="redeemPositions",
             args=[condition_id, amounts],
         )
-    def _encode_convert(self, neg_risk_market_id: Keccak256, index_set: int, amount: int) -> str:
+
+    def _encode_convert(
+        self, neg_risk_market_id: Keccak256, index_set: int, amount: int
+    ) -> str:
         return self.neg_risk_adapter.encode_abi(
             abi_element_identifier="convertPositions",
             args=[neg_risk_market_id, index_set, amount],
@@ -98,25 +123,37 @@ class PolymarketWeb3Client:
         Explicitly passing the proxy address is faster due to only one contract function call.
         """
         if address is None:
-            address = self.exchange.functions.getPolyProxyWalletAddress(self.account.address).call()
+            address = self.exchange.functions.getPolyProxyWalletAddress(
+                self.account.address
+            ).call()
         balance_res = self.usdc.functions.balanceOf(address).call()
         return float(balance_res / 1e6)
 
-    def get_token_balance(self, token_id: str, address: EthAddress | None = None) -> float:
+    def get_token_balance(
+        self, token_id: str, address: EthAddress | None = None
+    ) -> float:
         """Get the token balance of the given address."""
         if address is None:
-            address = self.exchange.functions.getPolyProxyWalletAddress(self.account.address).call()
-        balance_res = self.conditional_tokens.functions.balanceOf(address, int(token_id)).call()
+            address = self.exchange.functions.getPolyProxyWalletAddress(
+                self.account.address
+            ).call()
+        balance_res = self.conditional_tokens.functions.balanceOf(
+            address, int(token_id)
+        ).call()
         return float(balance_res / 1e6)
 
     def get_token_complement(self, token_id: str) -> Optional[str]:
         """Get the complement of the given token."""
         try:
-            return str(self.neg_risk_exchange.functions.getComplement(int(token_id)).call())
+            return str(
+                self.neg_risk_exchange.functions.getComplement(int(token_id)).call()
+            )
         except ContractCustomError as e:
             if e.args[0] in CUSTOM_ERROR_DICT:
                 try:
-                    return str(self.exchange.functions.getComplement(int(token_id)).call())
+                    return str(
+                        self.exchange.functions.getComplement(int(token_id)).call()
+                    )
                 except ContractCustomError as e2:
                     if e2.args[0] in CUSTOM_ERROR_DICT:
                         msg = f"{CUSTOM_ERROR_DICT[e2.args[0]]}"
@@ -132,71 +169,90 @@ class PolymarketWeb3Client:
         outcomeSlotCount is represented by the last two digits of question id). Returns a keccak256 hash of
         the oracle and question id.
         """
-        return "0x" + self.neg_risk_adapter.functions.getConditionId(question_id).call().hex()
+        return (
+            "0x"
+            + self.neg_risk_adapter.functions.getConditionId(question_id).call().hex()
+        )
 
-    def split_position(self, condition_id: Keccak256, amount: int, neg_risk: bool = True):
+    def split_position(
+        self, condition_id: Keccak256, amount: int, neg_risk: bool = True
+    ):
         """Splits usdc into two complementary positions of equal size."""
         nonce = self.w3.eth.get_transaction_count(self.account.address)
         amount = int(amount * 1e6)
 
         proxy_txn = {
             "typeCode": 1,
-            "to": self.neg_risk_adapter_address if neg_risk else self.conditional_tokens_address,
+            "to": self.neg_risk_adapter_address
+            if neg_risk
+            else self.conditional_tokens_address,
             "value": 0,
             "data": self._encode_split(condition_id, amount),
         }
 
         # Send transaction through proxy factory
-        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction({
-            "nonce": nonce,
-            "gasPrice": int(1.05 * self.w3.eth.gas_price),
-            "gas": 1000000,
-            "from": self.account.address,
-        })
+        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction(
+            {
+                "nonce": nonce,
+                "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                "gas": 1000000,
+                "from": self.account.address,
+            }
+        )
 
         # Sign and send transaction
         signed_txn = self.account.sign_transaction(txn_data)
-        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction).hex()
+        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        tx_hash_hex = tx_hash.hex()
 
-        print(f"Txn hash: {tx_hash}")
+        print(f"Txn hash: {tx_hash_hex}")
 
         # Wait for transaction to be mined
         self.w3.eth.wait_for_transaction_receipt(tx_hash)
 
         print("Done!")
 
-    def merge_position(self, condition_id: Keccak256, amount: int, neg_risk: bool = True):
+    def merge_position(
+        self, condition_id: Keccak256, amount: int, neg_risk: bool = True
+    ):
         """Merges two complementary positions into usdc."""
         nonce = self.w3.eth.get_transaction_count(self.account.address)
         amount = int(amount * 1e6)
 
         proxy_txn = {
             "typeCode": 1,
-            "to": self.neg_risk_adapter_address if neg_risk else self.conditional_tokens_address,
+            "to": self.neg_risk_adapter_address
+            if neg_risk
+            else self.conditional_tokens_address,
             "value": 0,
             "data": self._encode_merge(condition_id, amount),
         }
 
         # Send transaction through proxy factory
-        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction({
-            "nonce": nonce,
-            "gasPrice": int(1.05 * self.w3.eth.gas_price),
-            "gas": 1000000,
-            "from": self.account.address,
-        })
+        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction(
+            {
+                "nonce": nonce,
+                "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                "gas": 1000000,
+                "from": self.account.address,
+            }
+        )
 
         # Sign and send transaction
         signed_txn = self.account.sign_transaction(txn_data)
-        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction).hex()
+        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        tx_hash_hex = tx_hash.hex()
 
-        print(f"Txn hash: {tx_hash}")
+        print(f"Txn hash: {tx_hash_hex}")
 
         # Wait for transaction to be mined
         self.w3.eth.wait_for_transaction_receipt(tx_hash)
 
         print("Done!")
 
-    def redeem_position(self, condition_id: Keccak256, amounts: list[float], neg_risk: bool = True):
+    def redeem_position(
+        self, condition_id: Keccak256, amounts: list[float], neg_risk: bool = True
+    ):
         """
         Redeem a position into usdc.
 
@@ -209,31 +265,40 @@ class PolymarketWeb3Client:
 
         proxy_txn = {
             "typeCode": 1,
-            "to": self.neg_risk_adapter_address if neg_risk else self.conditional_tokens_address,
+            "to": self.neg_risk_adapter_address
+            if neg_risk
+            else self.conditional_tokens_address,
             "value": 0,
-            "data": self._encode_redeem_neg_risk(condition_id, amounts) if neg_risk else self._encode_redeem(condition_id),
+            "data": self._encode_redeem_neg_risk(condition_id, amounts)
+            if neg_risk
+            else self._encode_redeem(condition_id),
         }
 
         # Send transaction through proxy factory
-        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction({
-            "nonce": nonce,
-            "gasPrice": int(1.05 * self.w3.eth.gas_price),
-            "gas": 1000000,
-            "from": self.account.address,
-        })
+        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction(
+            {
+                "nonce": nonce,
+                "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                "gas": 1000000,
+                "from": self.account.address,
+            }
+        )
 
         # Sign and send transaction
         signed_txn = self.account.sign_transaction(txn_data)
-        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction).hex()
+        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        tx_hash_hex = tx_hash.hex()
 
-        print(f"Txn hash: {tx_hash}")
+        print(f"Txn hash: {tx_hash_hex}")
 
         # Wait for transaction to be mined
         self.w3.eth.wait_for_transaction_receipt(tx_hash)
 
         print("Done!")
 
-    def convert_positions(self, question_ids: list[Keccak256], neg_risk_market_id: Keccak256, amount: int):
+    def convert_positions(
+        self, question_ids: list[Keccak256], neg_risk_market_id: Keccak256, amount: int
+    ):
         nonce = self.w3.eth.get_transaction_count(self.account.address)
         amount = int(amount * 1e6)
 
@@ -241,20 +306,26 @@ class PolymarketWeb3Client:
             "typeCode": 1,
             "to": self.neg_risk_adapter_address,
             "value": 0,
-            "data": self._encode_convert(neg_risk_market_id, get_index_set(question_ids), amount),
+            "data": self._encode_convert(
+                neg_risk_market_id, get_index_set(question_ids), amount
+            ),
         }
 
-        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction({
-            "nonce": nonce,
-            "gasPrice": int(1.05 * self.w3.eth.gas_price),
-            "gas": 1000000,
-            "from": self.account.address,
-        })
+        txn_data = self.proxy_factory.functions.proxy([proxy_txn]).build_transaction(
+            {
+                "nonce": nonce,
+                "gasPrice": int(1.05 * self.w3.eth.gas_price),
+                "gas": 1000000,
+                "from": self.account.address,
+            }
+        )
 
+        # Sign and send transaction
         signed_txn = self.account.sign_transaction(txn_data)
-        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction).hex()
+        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        tx_hash_hex = tx_hash.hex()
 
-        print(f"Txn hash: {tx_hash}")
+        print(f"Txn hash: {tx_hash_hex}")
 
         # Wait for transaction to be mined
         self.w3.eth.wait_for_transaction_receipt(tx_hash)

polymarket_apis/clients/websockets_client.py

@@ -61,6 +61,7 @@ def _process_market_event(event):
         print(e.errors())
         print(event.json)
 
+
 def _process_user_event(event):
     try:
         message = event.json
@@ -75,6 +76,7 @@ def _process_user_event(event):
         print(event.text)
         print(e.errors(), "\n")
 
+
 def _process_live_data_event(event):
     try:
         message = event.json
@@ -87,7 +89,12 @@ def _process_live_data_event(event):
                 print(CommentEvent(**message), "\n")
             case "reaction_created" | "reaction_removed":
                 print(ReactionEvent(**message), "\n")
-            case "request_created" | "request_edited" | "request_canceled" | "request_expired":
+            case (
+                "request_created"
+                | "request_edited"
+                | "request_canceled"
+                | "request_expired"
+            ):
                 print(RequestEvent(**message), "\n")
             case "quote_created" | "quote_edited" | "quote_canceled" | "quote_expired":
                 print(QuoteEvent(**message), "\n")
@@ -117,13 +124,16 @@ def _process_live_data_event(event):
         print(e.errors(), "\n")
         print(event.text)
 
+
 class PolymarketWebsocketsClient:
     def __init__(self):
         self.url_market = "wss://ws-subscriptions-clob.polymarket.com/ws/market"
         self.url_user = "wss://ws-subscriptions-clob.polymarket.com/ws/user"
         self.url_live_data = "wss://ws-live-data.polymarket.com"
 
-    def market_socket(self, token_ids: list[str], process_event: Callable = _process_market_event):
+    def market_socket(
+        self, token_ids: list[str], process_event: Callable = _process_market_event
+    ):
         """
         Connect to the market websocket and subscribe to market events for specific token IDs.
 
@@ -142,7 +152,9 @@ class PolymarketWebsocketsClient:
             elif event.name == "text":
                 process_event(event)
 
-    def user_socket(self, creds: ApiCreds, process_event: Callable = _process_user_event):
+    def user_socket(
+        self, creds: ApiCreds, process_event: Callable = _process_user_event
+    ):
         """
         Connect to the user websocket and subscribe to user events.
 
@@ -161,7 +173,12 @@ class PolymarketWebsocketsClient:
             elif event.name == "text":
                 process_event(event)
 
-    def live_data_socket(self, subscriptions: list[dict[str, Any]], process_event: Callable = _process_live_data_event, creds: Optional[ApiCreds] = None):
+    def live_data_socket(
+        self,
+        subscriptions: list[dict[str, Any]],
+        process_event: Callable = _process_live_data_event,
+        creds: Optional[ApiCreds] = None,
+    ):
         # info on how to subscribe found at https://github.com/Polymarket/real-time-data-client?tab=readme-ov-file#subscribe
         """
         Connect to the live data websocket and subscribe to specified events.
@@ -175,13 +192,13 @@ class PolymarketWebsocketsClient:
         websocket = WebSocket(self.url_live_data)
 
         needs_auth = any(sub.get("topic") == "clob_user" for sub in subscriptions)
-        if needs_auth and creds is None:
-            msg = "ApiCreds credentials are required for the clob_user topic subscriptions"
-            raise AuthenticationRequiredError(msg)
 
         for event in persist(websocket):
             if event.name == "ready":
                 if needs_auth:
+                    if creds is None:
+                        msg = "ApiCreds credentials are required for the clob_user topic subscriptions"
+                        raise AuthenticationRequiredError(msg)
                     subscriptions_with_creds = []
                     for sub in subscriptions:
                         if sub.get("topic") == "clob_user":

polymarket_apis/types/__init__.py

@@ -0,0 +1,167 @@
+# python
+"""
+Type definitions for Polymarket APIs.
+
+This module contains all the Pydantic models and type definitions used across
+the Polymarket APIs.
+"""
+
+from .clob_types import (
+    ApiCreds,
+    AssetType,
+    BidAsk,
+    BookParams,
+    ClobMarket,
+    ContractConfig,
+    CreateOrderOptions,
+    DailyEarnedReward,
+    MarketOrderArgs,
+    MarketRewards,
+    Midpoint,
+    OpenOrder,
+    OrderArgs,
+    OrderBookSummary,
+    OrderCancelResponse,
+    OrderPostResponse,
+    OrderType,
+    PaginatedResponse,
+    PartialCreateOrderOptions,
+    PolygonTrade,
+    PostOrdersArgs,
+    Price,
+    PriceHistory,
+    RewardMarket,
+    Spread,
+    TickSize,
+    Token,
+    TokenBidAsk,
+    TokenBidAskDict,
+    TokenValue,
+    TokenValueDict,
+)
+from .common import (
+    EmptyString,
+    EthAddress,
+    FlexibleDatetime,
+    Keccak256,
+    TimeseriesPoint,
+)
+from .data_types import (
+    Activity,
+    Holder,
+    HolderResponse,
+    Position,
+    Trade,
+    User,
+    UserMetric,
+    UserRank,
+    ValueResponse,
+)
+from .gamma_types import (
+    ClobReward,
+    Event,
+    GammaMarket,
+    Pagination,
+    Series,
+    Tag,
+)
+from .websockets_types import (
+    ActivityOrderMatchEvent,
+    ActivityTradeEvent,
+    CommentEvent,
+    CryptoPriceSubscribeEvent,
+    CryptoPriceUpdateEvent,
+    ErrorEvent,
+    LastTradePriceEvent,
+    LiveDataLastTradePriceEvent,
+    LiveDataOrderBookSummaryEvent,
+    LiveDataOrderEvent,
+    LiveDataPriceChangeEvent,
+    LiveDataTickSizeChangeEvent,
+    LiveDataTradeEvent,
+    MarketStatusChangeEvent,
+    OrderBookSummaryEvent,
+    OrderEvent,
+    PriceChangeEvent,
+    QuoteEvent,
+    ReactionEvent,
+    RequestEvent,
+    TickSizeChangeEvent,
+    TradeEvent,
+)
+
+__all__ = [
+    "Activity",
+    "ActivityOrderMatchEvent",
+    "ActivityTradeEvent",
+    "ApiCreds",
+    "AssetType",
+    "BidAsk",
+    "BookParams",
+    "ClobMarket",
+    "ClobReward",
+    "CommentEvent",
+    "ContractConfig",
+    "CreateOrderOptions",
+    "CryptoPriceSubscribeEvent",
+    "CryptoPriceUpdateEvent",
+    "DailyEarnedReward",
+    "EmptyString",
+    "ErrorEvent",
+    "EthAddress",
+    "Event",
+    "FlexibleDatetime",
+    "GammaMarket",
+    "Holder",
+    "HolderResponse",
+    "Keccak256",
+    "LastTradePriceEvent",
+    "LiveDataLastTradePriceEvent",
+    "LiveDataOrderBookSummaryEvent",
+    "LiveDataOrderEvent",
+    "LiveDataPriceChangeEvent",
+    "LiveDataTickSizeChangeEvent",
+    "LiveDataTradeEvent",
+    "MarketOrderArgs",
+    "MarketRewards",
+    "MarketStatusChangeEvent",
+    "Midpoint",
+    "OpenOrder",
+    "OrderArgs",
+    "OrderBookSummary",
+    "OrderBookSummaryEvent",
+    "OrderCancelResponse",
+    "OrderEvent",
+    "OrderPostResponse",
+    "OrderType",
+    "PaginatedResponse",
+    "Pagination",
+    "PartialCreateOrderOptions",
+    "PolygonTrade",
+    "Position",
+    "PostOrdersArgs",
+    "Price",
+    "PriceChangeEvent",
+    "PriceHistory",
+    "QuoteEvent",
+    "ReactionEvent",
+    "RequestEvent",
+    "RewardMarket",
+    "Series",
+    "Spread",
+    "Tag",
+    "TickSize",
+    "TickSizeChangeEvent",
+    "TimeseriesPoint",
+    "Token",
+    "TokenBidAsk",
+    "TokenBidAskDict",
+    "TokenValue",
+    "TokenValueDict",
+    "Trade",
+    "TradeEvent",
+    "User",
+    "UserMetric",
+    "UserRank",
+    "ValueResponse",
+]